@adobe/ecs 0.0.0-stage → 0.2.0

package/src/implementation/world/plan.md

@@ -0,0 +1,81 @@
+# World.create implementation plan
+
+All of the runtime lives here. The only export is `create`, which moves here from `world/create.ts`. Rules:
+
+- No dependency on `@adobe/data`. Its code can be read for reference: `typed-buffer/`, `cache/memory-allocator.ts`, `ecs/store/core/`, and `ecs/database/calculate-system-order.ts`.
+- Performance comes first, then code size.
+- Kernels are compiled from the start. The compiler and Vite plugin run at build time, so they live beside this folder under `src/implementation/compiler/`, with their own package entry. Generated code reaches the runtime through one internal hook, `attachKernel(system, url)`.
+- Every module gets unit tests. The particle sample becomes a real end-to-end test.
+
+## 1.1 Main thread
+
+1. **Memory.** A shared `WebAssembly.Memory` from the start, so 1.2 and 1.3 don't change how data is stored.
+   - Columns are typed-array views into an arena allocator.
+   - Memory grows only at sync points, and views are refreshed afterwards.
+2. **Storage.**
+   - Archetypes are tables keyed by component set.
+   - Each linear component is a column in the arena. Each non-linear component is a JS array.
+   - The entity table maps each index to its archetype, row and generation. The free list holds a freed index back until the next flush.
+   - Each row stores `added` and `changed` ticks per component, as f64 so they never wrap. U32 ticks come in phase 2.
+3. **Registration.**
+   - Flatten composites.
+   - Check for duplicate system names and for missing schemas.
+   - Check unordered conflicts, including a lookup that reads a component its own system writes.
+   - Sort into tiers from `before`/`after`/`during`.
+   - Build each system's archetype matches lazily, and extend them as archetypes are created.
+4. **Running.**
+   - Run tiers in order.
+   - Change filters compare against each system's `lastRun`.
+   - Non-kernel systems get accessor rows: `defineProperty` getters and setters for the declared keys, with copy-on-read and whole-value writes. Values are immutable, so a copy is never edited.
+   - Resource-only systems run once per run.
+   - A system that throws rejects `run`.
+5. **Commands and sync points.**
+   - Each system has its own buffer, merged in tier order.
+   - Plan: compute each entity's net move from one archetype to another, and skip it when nothing is pending.
+   - Apply: swap-remove, insert spawned rows, then free indexes.
+   - `spawn` reserves a real entity through the atomic cursor.
+6. **Reads.**
+   - `query.select` and `count`, with `not`, `where` and `order`.
+   - `read.entity`, `read.component` and `read.resource`.
+   - Resources are stored as components on a single entity, with their initial values taken from the schema `default`.
+7. **Compiler** (`src/implementation/compiler/`):
+   - The bundler's parser (`this.parse`), plus a validator for the kernel subset.
+   - Maps each component, resource and lookup access to its slot by binding.
+   - Emits a JS kernel `(columns, start, end, resources, lookups, keys, args, commands, tick)` that records the shapes it assumed (`world/create/kernel.ts`). The runtime applies change filters and passes only passing row ranges. Kernel code references no module bindings, so it can move to a worker chunk.
+   - Registration checks those shapes against the schemas.
+   - In 1.1, kernels run on the main thread.
+8. **`dispose`,** and the particle sample as an end-to-end test.
+
+## 1.2 Workers
+
+- **Pool:** sized from `navigator.hardwareConcurrency` minus the main thread, and only with shared memory. The worker entry script (`worker.ts`) lives in this folder. Without cross-origin isolation, arrays use plain `ArrayBuffer`s and everything runs on the main thread, since growing unshared memory would detach every view.
+- **Kernel modules:** the plugin emits each kernel's `create` as its own module, an emitted chunk in builds and a virtual module in dev. The description carries its `url`, and the main thread and every worker `import()` it.
+- **Registration:**
+  - Post the shared `Memory` to each worker once.
+  - Each worker imports the kernel URLs and keeps the kernels by index, along with their column sources, lookups and keys as component ids.
+  - Registration resolves once every worker has finished loading.
+- **Shared state:**
+  - The spawn cursor and free list live in shared memory, and `reserve` is atomic, so workers spawn real entities.
+  - After each sync point, workers receive what changed in the layout: new schemas, new or grown archetypes, and the entity table. Messages are ordered, so a worker always has the layout before the tasks that use it. Shared memory doesn't detach as it grows, so nothing else is reposted.
+- **Dispatch:**
+  - Within a tier, kernels start first: an archetype of at least `minimumChunk` rows is split across workers, and smaller ones run on the main thread. WASM kernels claim pieces of about an eighth of a worker's share from a counter in shared memory, so performance and efficiency cores finish together; JS kernels take even shares. Then non-kernel systems run on the main thread while the workers work.
+  - Each worker applies the change filter to its own chunk.
+  - Each system has its own command buffer per run. A worker returns its chunk's commands with its reply, naming components by id. Buffers merge in (tier order, chunk order), so results don't depend on timing. Encoding commands into shared memory is phase 2.
+  - A failing system or chunk rejects the run after its tier finishes. Later tiers are skipped, and the commands so far still apply.
+- **Tests:** a world with zero workers and with three gives identical results, including commands and lookups issued from workers (`workers.browser.test.ts`, chromium). `dispose` terminates every worker.
+
+## 1.3 WASM
+
+- **Layout:** a linear component is one interleaved column per archetype, in its schema's layout: `storage` (WGSL storage-buffer rules), `vertex` (tight, 4-byte aligned), or by default tight for the CPU. A GPU layout is checked at registration. Kernels address a field as `row * stride + offset`.
+- **The compiler lowers each kernel once** and prints both the JS kernel and a `Program` IR from it. The IR is `null` for kernels with commands or lookups, which keep the JS kernel.
+- **Registration generates WASM** from the IR and the schemas' storage types: f64 arithmetic with typed-array store conversion, so scalar WASM is bit-identical to JS. It compiles once, and every worker instantiates the module against the shared `Memory`.
+- **SIMD**, in f32 lanes at storage precision:
+  - *Across rows*, four at a time, when every column is a dense f32 scalar.
+  - *Across rows of whole elements*, four at a time as `stride / 4` full vectors, when every store fuses into whole-element writes of components that read only same-stride components lane for lane (`p = p + v` on tight vec2 or vec3). The per-row loop takes the tail.
+  - *Within a row* otherwise: consecutive snapshot loads of a component's leaves become one vector load, and stores to its leaves whose values match lane for lane become one f32x4 operation and store. Loads and stores cover only the element's lanes.
+  - Anything else runs as scalar WASM, in the same row.
+- **Tests:** scalar WASM is bit-identical to JS; SIMD is within storage precision of JS; 0 and N workers stay identical with SIMD, since chunks start on 16-row boundaries.
+
+## Deferred
+
+Builtins, finalizers, rules, the ESLint rule, and GPU.

package/src/implementation/world/plan.ts

@@ -0,0 +1,72 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/**
+ * A sync point's plan: each touched entity's net change, as reusable parallel arrays rather than an object per entity.
+ * `to` is where it ends up; its values are command ranges, applied in issue order so later values win. Each world has
+ * its own, since a sync point can wait for the GPU between planning and applying.
+ */
+export type Plan = {
+    count: number;
+    /** Entries made by spawns; each consumed one reservation. */
+    spawned: number;
+    /** Commands that did nothing, since their entity wasn't alive. */
+    dropped: number;
+    entity: Float64Array<ArrayBuffer>;
+    /** Archetype id, or -1 for an entity spawned in this sync point. */
+    from: Int32Array<ArrayBuffer>;
+    to: Int32Array<ArrayBuffer>;
+    despawned: Uint8Array<ArrayBuffer>;
+    /** While applying: the row an entity leaves in `from`, kept current as rows swap into holes; -1 for none. */
+    row: Int32Array<ArrayBuffer>;
+    /** While applying: the pair of archetypes a moving entry is in, by index into the pairs; -1 for one staying. */
+    pair: Int32Array<ArrayBuffer>;
+    /** While applying: the pairs of source and target archetype entries move between, by key, with their entries in order. */
+    readonly pairs: Pairs;
+    /** The first command range: queued buffer, start and end. Most entities have one. */
+    buffer: Int32Array<ArrayBuffer>;
+    start: Int32Array<ArrayBuffer>;
+    end: Int32Array<ArrayBuffer>;
+    /** Further ranges, as buffer, start, end triples. */
+    readonly more: Map<number, number[]>;
+    /** Components removed and added again here, so their `added` tick is new although `from` had them. */
+    readonly fresh: Map<number, number[]>;
+    /** Where each entity index's entry is, or -1; reset after each sync point. */
+    slots: Int32Array;
+};
+
+/**
+ * Source and target archetype pairs, reused across sync points: `from[p]` (-1 for spawns) and `to[p]`, the number of
+ * entries moving between them, and where they start in `order`, which lists every moving entry by pair, in entry order.
+ * When each pair's entries are consecutive entries, as a system's spawns or moves from one archetype are, each pair
+ * starts at its first entry and `order` lists entries in order.
+ */
+export type Pairs = {
+    readonly byKey: Map<number, number>;
+    readonly from: number[];
+    readonly to: number[];
+    readonly count: number[];
+    readonly start: number[];
+    /** Entries that leave a row, which is removed after the pairs arrive. */
+    leaving: number;
+    order: Int32Array<ArrayBuffer>;
+};
+
+const initialEntries = 64;
+
+export const createPlan = (): Plan => ({
+    count: 0,
+    spawned: 0,
+    dropped: 0,
+    entity: new Float64Array(initialEntries),
+    from: new Int32Array(initialEntries),
+    to: new Int32Array(initialEntries),
+    despawned: new Uint8Array(initialEntries),
+    row: new Int32Array(initialEntries),
+    pair: new Int32Array(initialEntries),
+    pairs: { byKey: new Map(), from: [], to: [], count: [], start: [], leaving: 0, order: new Int32Array(initialEntries) },
+    buffer: new Int32Array(initialEntries),
+    start: new Int32Array(initialEntries),
+    end: new Int32Array(initialEntries),
+    more: new Map(),
+    fresh: new Map(),
+    slots: new Int32Array(0),
+});

package/src/implementation/world/platforms.test-helper.ts

@@ -0,0 +1,68 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="node" />
+import type { ToWorker } from './protocol.js';
+import { browserPort, nodePort, platformWorkers, type WorkerPlatform, type WorkerPort } from './worker-platform.js';
+
+/** The platform's workers, counting what the world does with them: workers started and ended, and messages by kind. */
+export type Counting = {
+    readonly platform: WorkerPlatform;
+    /** Every port started, in order. */
+    readonly ports: readonly WorkerPort[];
+    readonly started: () => number;
+    readonly terminated: () => number;
+    /** Messages of this kind posted to any worker so far. */
+    readonly posted: (kind: ToWorker["kind"]) => number;
+    /** Completions so far whose task wrote past its command ring's size. */
+    readonly spilled: () => number;
+};
+
+export const countingWorkers = (base: WorkerPlatform | null = platformWorkers()): Counting => {
+    if (base === null) throw new Error("This platform has no workers.");
+    const ports: WorkerPort[] = [];
+    const posted = new Map<ToWorker["kind"], number>();
+    let terminated = 0;
+    let spilled = 0;
+    const start = (): WorkerPort | null => {
+        const port = base.start();
+        if (port === null) return null;
+        const counted: WorkerPort = {
+            ...port,
+            post: (message, transfer) => {
+                posted.set(message.kind, (posted.get(message.kind) ?? 0) + 1);
+                port.post(message, transfer);
+            },
+            onMessage: handler => port.onMessage(message => {
+                if (message.kind !== "tables" && message.spill !== null) spilled++;
+                handler(message);
+            }),
+            terminate: () => {
+                terminated++;
+                return port.terminate();
+            },
+        };
+        ports.push(counted);
+        return counted;
+    };
+    return {
+        platform: { count: base.count, start },
+        ports,
+        started: () => ports.length,
+        terminated: () => terminated,
+        posted: kind => posted.get(kind) ?? 0,
+        spilled: () => spilled,
+    };
+};
+
+/** `count` of the platform's workers. */
+export const startWorkers = (count: number, platform: WorkerPlatform | null = platformWorkers()): WorkerPort[] => Array.from({ length: count }, () => {
+    const port = platform?.start() ?? null;
+    if (port === null) throw new Error("This platform has no workers.");
+    return port;
+});
+
+/** A worker whose script doesn't exist, so it fails to load. */
+export const missingWorker = (): WorkerPort => {
+    if (typeof Worker === "function") return browserPort(new Worker("/@missing/worker.js", { type: "module" }));
+    const threads = globalThis.process.getBuiltinModule("node:worker_threads");
+    return nodePort(new threads.Worker(new URL("./missing-worker.js", import.meta.url)));
+};

package/src/implementation/world/pool-size.cases.ts

@@ -0,0 +1,41 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import type * as Fixture from "./pool-size.fixture.js";
+
+/** The `workers` resource sizes the pool: the cases, over the fixture built for node or from source. */
+export const poolSizeCases = (load: () => Promise<typeof Fixture>) => describe("the workers resource", () => {
+    it("is null by default, the platform's choice: a worker per hardware thread but the world's", async () => {
+        const fixture = await load();
+        const platform = fixture.platformCount();
+        expect(platform).toBe(Math.max(1, navigator.hardwareConcurrency - 1));
+        expect(await fixture.byDefault()).toEqual({ resource: null, started: platform });
+    });
+    it("honors a number, and null again gives the platform's choice", async () => {
+        const fixture = await load();
+        expect((await fixture.resized(1, [null])).started).toEqual([1, 1 + fixture.platformCount()]);
+    });
+    it("starts the pool only once a kernel has rows enough for workers", async () => {
+        const fixture = await load();
+        const { started, values } = await fixture.whenWarranted();
+        expect(started).toEqual([0, fixture.platformCount()]);
+        expect(values).toEqual([0, 4, 8, 12]);
+    });
+    it("starts no pool for rows no kernel runs over", async () => {
+        expect(await (await load()).unmatched()).toBe(0);
+    });
+    it("reports a kernel that fails to load on workers as the pool starts, and runs it here from then on", async () => {
+        const fixture = await load();
+        const { failures, loads, values } = await fixture.failedLoad();
+        expect(failures[0]).toEqual([expect.stringMatching(/^The kernel pool's workers failed: .*no kernel here/)]);
+        expect(failures[1]).toEqual([]);
+        expect(loads[1]).toBe(loads[0]);
+        expect(values).toEqual([0, 4, 8, 12]);
+    });
+    it("sizes the kernel pool at the next sync point, with the same results", async () => {
+        const fixture = await load();
+        const { started, values } = await fixture.resized(2, [3, 0]);
+        expect(started).toEqual([2, 5, 5]);
+        expect(values.slice(0, 4)).toEqual([0, 8, 16, 24]);
+        expect(values[4095]).toBe(4095 * 8);
+    });
+});

package/src/implementation/world/pool-size.fixture.ts

@@ -0,0 +1,158 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+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 { Observe } from "../../observe/index.js";
+import { countingWorkers } from "./platforms.test-helper.js";
+import { catchOutOfBand } from "./outcomes.test-helper.js";
+import type { WorkerPlatform } from "./worker-platform.js";
+import type { F32 } from "../../interface/math/index.js";
+
+/** Scenarios of the `workers` resource sizing the pool, run built in node and from source in chromium. */
+
+const value = Symbol("poolSizeTest/value");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [value]: { type: F32 };
+    }
+}
+
+const other = Symbol("poolSizeTest/other");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [other]: { type: F32 };
+    }
+}
+const others = System.create({}, ({ commands }) => {
+    for (let i = 0; i < 4096; i++) commands.spawn([other])({ [other]: i });
+});
+
+const seed = System.create({}, ({ commands }) => {
+    for (let i = 0; i < 4096; i++) commands.spawn([value])({ [value]: i });
+});
+const few = System.create({}, ({ commands }) => {
+    for (let i = 0; i < 16; i++) commands.spawn([value])({ [value]: i });
+});
+const double = System.create({ kernel: true, components: { with: [value] } }, row => { row[value] = row[value] * 2; });
+const resize = System.create({}, ({ resources }, input: { readonly size: number | null }) => {
+    resources[workers] = input.size;
+});
+
+/** The platform's pool size: a worker per hardware thread but the world's. */
+export const platformCount = (): number => countingWorkers().platform.count;
+
+/** With the resource at its default: its value, and the workers started by the first kernel. */
+export const byDefault = async (): Promise<{ readonly resource: number | null; readonly started: number }> => {
+    const counting = countingWorkers();
+    const world = createWorld({}, { minimumChunk: 64, pool: counting.platform });
+    try {
+        const resource = await Observe.toPromise(Observe.resource(world, workers));
+        await world.run(seed);
+        await world.run(double);
+        return { resource, started: counting.started() };
+    }
+    finally {
+        await world.dispose();
+    }
+};
+
+/**
+ * Starting at `initial`, then set to each of `sizes` with a kernel run after each: workers started so far after each
+ * step, and the values the kernels doubled.
+ */
+export const resized = async (initial: number, sizes: readonly (number | null)[]): Promise<{ readonly started: readonly number[]; readonly values: readonly (number | null)[] }> => {
+    const counting = countingWorkers();
+    const world = createWorld({ [workers]: initial }, { minimumChunk: 64, pool: counting.platform });
+    try {
+        await world.run(seed);
+        await world.run(double);
+        const started = [counting.started()];
+        for (const size of sizes) {
+            await world.run(resize, { size });
+            await world.run(double);
+            started.push(counting.started());
+        }
+        return { started, values: await readEach(world, await select(world, { required: [value] }), value) };
+    }
+    finally {
+        await world.dispose();
+    }
+};
+
+/**
+ * Workers started after a kernel runs over fewer rows than a piece for a worker, then after it runs over enough, and
+ * the first values it doubled.
+ */
+export const whenWarranted = async (): Promise<{ readonly started: readonly number[]; readonly values: readonly (number | null)[] }> => {
+    const counting = countingWorkers();
+    const world = createWorld({}, { minimumChunk: 64, pool: counting.platform });
+    try {
+        await world.run(few);
+        await world.run(double);
+        const started = [counting.started()];
+        await world.run(seed);
+        await world.run(double);
+        started.push(counting.started());
+        return { started, values: (await readEach(world, await select(world, { required: [value] }), value)).slice(0, 4) };
+    }
+    finally {
+        await world.dispose();
+    }
+};
+
+/** The platform's workers, failing every kernel load: each kernel's module is one that throws. */
+const failingLoads = (): { readonly platform: WorkerPlatform; readonly loads: () => number } => {
+    const counting = countingWorkers();
+    const broken = "data:text/javascript,throw new Error('no kernel here')";
+    const start = () => {
+        const port = counting.platform.start();
+        if (port === null) return null;
+        return { ...port, post: ((message, transfer) => port.post(message.kind === "kernels" ? { ...message, kernels: message.kernels.map(kernel => ({ ...kernel, url: broken })) } : message, transfer)) satisfies typeof port.post };
+    };
+    return { platform: { count: counting.platform.count, start }, loads: () => counting.posted("kernels") };
+};
+
+/**
+ * A kernel whose load fails on workers when the pool starts: the failures of that run's report and of the next, the
+ * kernel loads posted after each, and the values its runs doubled, here.
+ */
+export const failedLoad = async (): Promise<{ readonly failures: readonly (readonly string[])[]; readonly loads: readonly number[]; readonly values: readonly (number | null)[] }> => {
+    const failing = failingLoads();
+    const world = createWorld({ [workers]: 2 }, { minimumChunk: 64, pool: failing.platform });
+    try {
+        // Registered while no archetype warrants workers, so the pool starts in a later run.
+        await world.run(double);
+        await world.run(seed);
+        const failures: string[][] = [];
+        const loads: number[] = [];
+        // Workers failing to load are reported out of band.
+        using reported = catchOutOfBand();
+        for (let i = 0; i < 2; i++) {
+            const before = reported.errors.length;
+            await world.run(double);
+            failures.push(reported.messages().slice(before));
+            loads.push(failing.loads());
+        }
+        return { failures, loads, values: (await readEach(world, await select(world, { required: [value] }), value)).slice(0, 4) };
+    }
+    finally {
+        await world.dispose();
+    }
+};
+
+/** Workers started after a kernel runs over few rows in a world whose largest archetype no kernel matches. */
+export const unmatched = async (): Promise<number> => {
+    const counting = countingWorkers();
+    const world = createWorld({}, { minimumChunk: 64, pool: counting.platform });
+    try {
+        await world.run(others);
+        await world.run(few);
+        await world.run(double);
+        await world.run(double);
+        return counting.started();
+    }
+    finally {
+        await world.dispose();
+    }
+};

package/src/implementation/world/pool.cases.ts

@@ -0,0 +1,31 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import type * as Fixture from "./pool.fixture.js";
+
+/** The pool over its ports: the cases, over the fixture built for node or from source. */
+export const poolCases = (load: () => Promise<typeof Fixture>) => describe("createPool", () => {
+    it("fails tasks on a worker that couldn't load, rather than hang", async () => {
+        const fixture = await load();
+        const { message, same } = await fixture.unloadable();
+        expect(message).toContain("failed");
+        // Later tasks fail immediately too.
+        expect(same).toBe(true);
+    }, 30000);
+
+    it("releases its control state when terminated, so pools of new sizes don't grow what the arena holds", async () => {
+        const fixture = await load();
+        for (const [before, after] of await fixture.released()) {
+            expect(before).toBeGreaterThan(0);
+            expect(after).toBe(0);
+        }
+    }, 30000);
+
+    it("fails every task of a worker whose memory is shorter than the length the world stored", async () => {
+        const fixture = await load();
+        const [before, during, after] = await fixture.shortMemory();
+        expect(before).toBeUndefined();
+        expect(during).toContain("short of");
+        // The worker stays broken, since views it made may be stale.
+        expect(after).toContain("short of");
+    }, 30000);
+});

package/src/implementation/world/pool.fixture.ts

@@ -0,0 +1,55 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { createMemory, pageBytes, pagesWord, type Memory } from "./memory.js";
+import { createPool } from "./pool.js";
+import { idleKernel } from "./protocol.js";
+import { missingWorker, startWorkers } from "./platforms.test-helper.js";
+
+/** Scenarios of the pool over its ports, run built in node and from source in chromium. */
+
+/** Two tasks on a worker that couldn't load: the first's error, and whether the second failed with the same one. */
+export const unloadable = async (): Promise<{ readonly message: string | undefined; readonly same: boolean }> => {
+    const pool = createPool([missingWorker()], createMemory(true));
+    const first = await pool.request(0, { kind: "kernels", kernels: [] });
+    const second = await pool.request(0, { kind: "kernels", kernels: [] });
+    await pool.terminate();
+    return { message: first.error?.message, same: second.error === first.error };
+};
+
+/** Bytes the arena holds for pools of 1 to 4 workers, each with every window opened: before and after `terminate`. */
+export const released = async (): Promise<readonly (readonly [number, number])[]> => {
+    const arena = createMemory(true);
+    /** Bytes allocated and not yet freed. */
+    let held = 0;
+    const counting: Memory = {
+        ...arena,
+        allocate: bytes => { held += bytes; return arena.allocate(bytes); },
+        free: (offset, bytes) => { held -= bytes; arena.free(offset, bytes); },
+    };
+    const results: [number, number][] = [];
+    for (let size = 1; size <= 4; size++) {
+        const pool = createPool(startWorkers(size), counting);
+        // Open each worker's window, so each has used the control lines being released.
+        await Promise.all(pool.claimed(0, size, { kernel: idleKernel, archetype: -1, start: 0, end: 0, tick: 0, lastRun: 0, scalars: [], partials: -1, partialBytes: 0 }, 1));
+        const before = held;
+        await pool.terminate();
+        results.push([before, held]);
+    }
+    return results;
+};
+
+/**
+ * A worker whose memory is shorter than the length the world stored: its errors before, while and after the length
+ * is past its buffer.
+ */
+export const shortMemory = async (): Promise<readonly (string | undefined)[]> => {
+    const memory = createMemory(true);
+    const pool = createPool(startWorkers(1), memory);
+    const before = (await pool.request(0, { kind: "kernels", kernels: [] })).error?.message;
+    const pages = memory.memory.buffer.byteLength / pageBytes;
+    Atomics.store(memory.header, pagesWord, pages + 1);
+    const during = (await pool.request(0, { kind: "kernels", kernels: [] })).error?.message;
+    Atomics.store(memory.header, pagesWord, pages);
+    const after = (await pool.request(0, { kind: "kernels", kernels: [] })).error?.message;
+    await pool.terminate();
+    return [before, during, after];
+};