@adobe/ecs 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,67 @@
+/// <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,23 @@
+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("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,66 @@
+import { Component } from "../../interface/component/component.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 { Observe } from "../../observe/index.js";
+import { countingWorkers } from "./platforms.test-helper.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: number };
+    }
+}
+Component.register(value, { type: { type: "number", precision: 1 } });
+
+const seed = System.create({ name: "poolSizeTest/seed" }, ({ commands }) => {
+    for (let i = 0; i < 4096; i++) commands.spawn([value])({ [value]: i });
+});
+const double = System.create({ name: "poolSizeTest/double", kernel: "cpu", components: { write: [value] } }, row => { row[value] = row[value] * 2; });
+const resize = System.create({ name: "poolSizeTest/resize", input: { type: "object", properties: { size: { anyOf: [{ type: "integer" }, { type: "null" }] } } }, resources: { write: [workers] } }, ({ input, resources }) => {
+    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();
+    }
+};

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

@@ -0,0 +1,30 @@
+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,54 @@
+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];
+};

package/src/implementation/world/pool.ts

@@ -0,0 +1,323 @@
+import { allocateArray, freeArray } from './arrays.js';
+import { emptyBuffer, type CommandBuffer } from './buffer.js';
+import type { Memory } from './memory.js';
+import { maximumPieces, startRanges } from './claims.js';
+import { controlWords, splitCount, done, epoch, lineWords, posted, ringBase, ringCapacity, ringCursor, ringNeeded, ringSize, signal, taskFields, taskWords, type ToWorker, type WorkerError } from './protocol.js';
+import type { MergeTag, Segment } from './command-ring.js';
+import type { WorkerPort } from './worker-platform.js';
+
+type Task = Extract<ToWorker, { task: number }>;
+type Request = Task extends infer T ? T extends Task ? Omit<T, "task"> : never : never;
+
+/**
+ * A task's commands, plus its error if it failed partway; what it issued before the error still applies. A message
+ * task's commands and spawns are its segment of its worker's command ring, which the world drains.
+ */
+export type TaskResult = { readonly commands: CommandBuffer; readonly segment?: Segment; readonly error?: Error; readonly kernels?: number };
+
+/** A WASM kernel task: everything is a number, so it travels through shared memory instead of a message. */
+export type FastTask = {
+    readonly kernel: number;
+    readonly archetype: number;
+    readonly start: number;
+    readonly end: number;
+    readonly tick: number;
+    readonly lastRun: number;
+    readonly scalars: readonly number[];
+    /**
+     * The byte address of the task's first reduction partials, or -1 without reductions; they follow the scalars, and
+     * count against `maximumScalars`. A worker running claimed pieces folds piece `p` into the partials `p * partialBytes` past it.
+     */
+    readonly partials: number;
+    readonly partialBytes: number;
+};
+
+/**
+ * Workers sharing the world's memory, one per port. Messages to one worker are handled in the order they're posted.
+ * `claimed` tasks go through a ring in shared memory while workers wait on it in a window, which costs one message to
+ * open; a message, a broadcast or `close` ends the window, after the tasks already posted.
+ */
+export type Pool = {
+    readonly size: number;
+    readonly broadcast: (message: Exclude<ToWorker, { task: number }>) => void;
+    /** Posts a task to one worker. Never rejects: a failed task or a dead worker resolves with an error. */
+    readonly request: (worker: number, message: Request) => Promise<TaskResult>;
+    /**
+     * Posts one task to each of `workers` workers from `first`, which claim `grain`-row pieces of the task's range:
+     * each from its own home range first, then from others' (`claims.ts`), so faster workers take more and a worker
+     * mapped to the same range each tier finds its rows in cache. With no room for claims, splits the range evenly.
+     */
+    readonly claimed: (first: number, workers: number, task: FastTask, grain: number) => Promise<TaskResult>[];
+    /** How many workers were posted a task since the last call, which starts the count again. */
+    readonly takePosted: () => number;
+    readonly close: () => void;
+    /**
+     * At a sync point, once its segments are drained and while no task runs: empties every command ring, growing each
+     * one a task overflowed to what its tasks needed.
+     */
+    readonly rewind: () => void;
+    /**
+     * Ends the workers, through their ports, then releases the pool's control state to the arena once every worker that waited on it has
+     * left its window, as each acknowledges a message. One that doesn't within `releaseTimeout`, or that died with a
+     * window open, may still touch it, so it's kept.
+     */
+    readonly terminate: () => Promise<void>;
+};
+
+/** How long `terminate` waits for workers to leave their windows before keeping the control state. */
+const releaseTimeout = 1000;
+/** A command ring's first size in bytes; a sync point grows it to what a run's tasks needed. */
+const initialRingBytes = 1 << 16;
+
+const errorOf = ({ name, message, stack }: WorkerError): Error => Object.assign(new Error(message), { name, stack });
+
+/** A task waiting for its completion, with the merge tag of a run's segment, or null for one that writes none. */
+type Pending = { readonly settle: (result: TaskResult) => void; readonly tag: MergeTag | null };
+
+type Slot = {
+    readonly port: WorkerPort;
+    readonly pending: Map<number, Pending>;
+    /** Set once the worker fails to load, crashes or exits; it gets no more tasks. */
+    dead: Error | null;
+};
+
+type Block = { readonly offset: number; readonly bytes: number };
+
+/** Zeroed Int32 words starting on a cache line, so a block of whole lines shares none with other arrays; `blocks` records the block. */
+const allocateLines = (arena: Memory, words: number, blocks: Block[]): Int32Array => {
+    const lineBytes = lineWords * 4;
+    const bytes = words * 4 + lineBytes;
+    const offset = arena.allocate(bytes);
+    blocks.push({ offset, bytes });
+    return new Int32Array(arena.memory.buffer, Math.ceil(offset / lineBytes) * lineBytes, words).fill(0);
+};
+
+export const createPool = (ports: readonly WorkerPort[], arena: Memory): Pool => {
+    const { memory } = arena;
+    const size = ports.length;
+    let nextTask = 0;
+    const lines: Block[] = [];
+    const control = allocateLines(arena, size * controlWords, lines);
+    const statuses = allocateLines(arena, size * ringSize, lines);
+    const payloads = allocateArray(arena, Float64Array, size * ringSize * taskWords);
+    const claims = allocateLines(arena, splitCount * size * lineWords, lines);
+    /** Splits' claim slots no split in flight uses: one is reused only once every task of its split is done. */
+    const freeSplits = Array.from({ length: splitCount }, (_, split) => split);
+    const open = new Array<boolean>(size).fill(false);
+    /** Whether each worker was ever given a window or a run, and so may touch the control state. */
+    const windowed = new Array<boolean>(size).fill(false);
+    const sent = new Array<number>(size).fill(0);
+    /** Writes held back by a full ring, chained so they stay in order. */
+    const waiting = new Array<number>(size).fill(0);
+    const chains = Array.from({ length: size }, (): Promise<void> => Promise.resolve());
+    /** Each worker's command ring, in the memory. */
+    const rings: Block[] = Array.from({ length: size }, () => {
+        const bytes = initialRingBytes;
+        return { offset: arena.allocate(bytes), bytes };
+    });
+    const placeRing = (worker: number): void => {
+        const base = worker * controlWords;
+        Atomics.store(control, base + ringBase, rings[worker].offset);
+        Atomics.store(control, base + ringCapacity, rings[worker].bytes);
+        Atomics.store(control, base + ringCursor, 0);
+        Atomics.store(control, base + ringNeeded, 0);
+    };
+    for (let worker = 0; worker < size; worker++) placeRing(worker);
+    /** Whether a task wrote into a command ring since the last rewind. */
+    let written = false;
+    /** The workers posted a task since `takePosted` last ran, and how many. */
+    const postedTo = new Uint8Array(size);
+    let postedCount = 0;
+    const markPosted = (worker: number): void => {
+        if (postedTo[worker] !== 0) return;
+        postedTo[worker] = 1;
+        postedCount++;
+    };
+    const kill =(slot: Slot, error: Error): void => {
+        slot.dead ??= error;
+        for (const { settle } of slot.pending.values()) settle({ commands: emptyBuffer, error: slot.dead });
+        slot.pending.clear();
+    };
+    const slots: Slot[] = ports.map((port, worker) => {
+        const slot: Slot = { port, pending: new Map(), dead: null };
+        port.onMessage(message => {
+            const pending = slot.pending.get(message.task);
+            slot.pending.delete(message.task);
+            if (pending === undefined) return;
+            if (message.kind === "tables") return pending.settle({ commands: emptyBuffer, kernels: message.kernels });
+            const { start, end, spill } = message;
+            const wrote = end > start || spill !== null;
+            if (wrote) written = true;
+            // The ring moves only at a rewind, which waits for every task.
+            const segment = wrote && pending.tag !== null ? { bytes: spill ?? new Uint8Array(memory.buffer, rings[worker].offset + start, end - start), tag: pending.tag } : undefined;
+            pending.settle(message.kind === "done" ? { commands: emptyBuffer, segment } : { commands: emptyBuffer, segment, error: errorOf(message.error) });
+        });
+        port.onDeath(error => kill(slot, error));
+        port.post({ kind: "memory", memory, header: arena.header.byteOffset, control: control.byteOffset + worker * controlWords * 4 });
+        return slot;
+    });
+    const wake = (worker: number): void => {
+        Atomics.add(control, worker * controlWords + signal, 1);
+        Atomics.notify(control, worker * controlWords + signal);
+    };
+
+    const close = (): void => {
+        for (let worker = 0; worker < size; worker++) {
+            if (!open[worker]) continue;
+            open[worker] = false;
+            Atomics.add(control, worker * controlWords + epoch, 1);
+            wake(worker);
+        }
+    };
+
+    /** Opens a worker's window for the current epoch, after any messages already posted to it. */
+    const ensureOpen = (worker: number): void => {
+        if (open[worker]) return;
+        open[worker] = true;
+        windowed[worker] = true;
+        const current = Atomics.load(control, worker * controlWords + epoch);
+        slots[worker].port.post({ kind: "window", control: control.byteOffset, statuses: statuses.byteOffset, payloads: payloads.byteOffset, claims: claims.byteOffset, worker, epoch: current });
+    };
+
+    /** One brief spin for all waiters of a batch of tasks, which are short, before waiting without blocking. */
+    let spinUntil = 0;
+    /** Resolves once the worker has done `count` tasks. */
+    const whenDone = async (worker: number, count: number): Promise<void> => {
+        const index = worker * controlWords + done;
+        while (Atomics.load(control, index) < count) {
+            if (slots[worker].dead !== null) return;
+            if (performance.now() < spinUntil) continue;
+            const current = Atomics.load(control, index);
+            if (current >= count) return;
+            const waited = Atomics.waitAsync(control, index, current, 50);
+            if (waited.async) await waited.value;
+        }
+    };
+
+    const post = (worker: number, task: FastTask, line: number, grain: number, self: number, participants: number): Promise<TaskResult> => {
+        markPosted(worker);
+        const slot = slots[worker];
+        if (slot.dead !== null) return Promise.resolve({ commands: emptyBuffer, error: slot.dead });
+        const count = ++sent[worker];
+        const ring = (count - 1) % ringSize;
+        spinUntil = performance.now() + 2;
+        const write = (): void => {
+            // A write held back past a close reopens the window, behind the messages posted since.
+            ensureOpen(worker);
+            const current = Atomics.load(control, worker * controlWords + epoch);
+            const base = (worker * ringSize + ring) * taskWords;
+            payloads.set([task.kernel, task.archetype, task.start, task.end, task.tick, task.lastRun, current, task.scalars.length, line, grain, self, participants], base);
+            payloads.set(task.partials < 0 ? task.scalars : [...task.scalars, task.partials, task.partialBytes], base + taskFields);
+            Atomics.store(control, worker * controlWords + posted, count);
+            wake(worker);
+        };
+        // Written now when there's room, so the worker starts at once; otherwise in order, once the worker frees a slot.
+        let written: Promise<void>;
+        if (waiting[worker] === 0 && count - Atomics.load(control, worker * controlWords + done) <= ringSize) {
+            write();
+            written = Promise.resolve();
+        }
+        else {
+            waiting[worker]++;
+            written = chains[worker] = chains[worker].then(async () => {
+                await whenDone(worker, count - ringSize);
+                write();
+                waiting[worker]--;
+            });
+        }
+        return (async (): Promise<TaskResult> => {
+            await written;
+            await whenDone(worker, count);
+            if (slot.dead !== null) return { commands: emptyBuffer, error: slot.dead };
+            // The worker records each task's number, negated if it failed, so a reused slot can't hide a failure.
+            const failed = Atomics.load(statuses, worker * ringSize + ring) === -count;
+            return failed ? { commands: emptyBuffer, error: new Error("A world worker's kernel failed.") } : { commands: emptyBuffer };
+        })();
+    };
+
+    const claimed = (first: number, workers: number, task: FastTask, grain: number): Promise<TaskResult>[] => {
+        const pieces = Math.ceil((task.end - task.start) / grain);
+        const split = pieces <= maximumPieces ? freeSplits.pop() : undefined;
+        if (split === undefined) {
+            const share = Math.ceil((task.end - task.start) / workers / grain) * grain;
+            // Each share runs as the grain-row pieces it holds, into those pieces' partials, as claims would.
+            return Array.from({ length: workers }, (_, i) =>
+                post((first + i) % size, {
+                    ...task, start: task.start + i * share, end: Math.min(task.end, task.start + (i + 1) * share),
+                    partials: task.partials < 0 ? -1 : task.partials + (i * share / grain) * task.partialBytes,
+                }, -1, grain, 0, 0));
+        }
+        const line = split * size;
+        startRanges(claims.subarray(line * lineWords, (line + workers) * lineWords), workers, pieces);
+        const results = Array.from({ length: workers }, (_, i) => post((first + i) % size, task, line, grain, i, workers));
+        void Promise.all(results).then(() => freeSplits.push(split));
+        return results;
+    };
+
+    return {
+        size,
+        claimed,
+        takePosted: () => {
+            const count = postedCount;
+            if (count !== 0) {
+                postedTo.fill(0);
+                postedCount = 0;
+            }
+            return count;
+        },
+        broadcast: message => {
+            close();
+            for (const slot of slots) if (slot.dead === null) slot.port.post(message);
+        },
+        close,
+        rewind: () => {
+            if (!written) return;
+            written = false;
+            for (let worker = 0; worker < size; worker++) {
+                // A dead worker gets no more tasks, but may still be writing, so its ring is left to it.
+                if (slots[worker].dead !== null) continue;
+                const needed = Atomics.load(control, worker * controlWords + ringNeeded);
+                const ring = rings[worker];
+                if (needed > ring.bytes) {
+                    arena.free(ring.offset, ring.bytes);
+                    const bytes = Math.max(needed, 2 * ring.bytes);
+                    rings[worker] = { offset: arena.allocate(bytes), bytes };
+                }
+                placeRing(worker);
+            }
+        },
+        request: (worker, message) => new Promise(settle => {
+            close();
+            markPosted(worker);
+            const slot = slots[worker];
+            if (slot.dead !== null) return settle({ commands: emptyBuffer, error: slot.dead });
+            const task = nextTask++;
+            // Its command ring is in the control state, so `terminate` waits for it to leave, as for a window.
+            windowed[worker] = true;
+            slot.pending.set(task, { settle, tag: message.kind === "run" ? { tick: message.tick, archetype: message.archetype, start: message.start } : null });
+            slot.port.post({ ...message, task });
+        }),
+        terminate: async () => {
+            close();
+            // A worker handles messages only outside its window, so its reply means it has left and won't enter again.
+            const left = slots.map((slot, worker) => !windowed[worker] ? Promise.resolve(true)
+                : slot.dead !== null ? Promise.resolve(false)
+                : new Promise<boolean>(settle => {
+                    const task = nextTask++;
+                    slot.pending.set(task, { settle: result => settle(result.error === undefined), tag: null });
+                    slot.port.post({ kind: "kernels", kernels: [], task });
+                }));
+            let timer: ReturnType<typeof setTimeout> | undefined;
+            const timeout = new Promise<boolean>(settle => { timer = setTimeout(() => settle(false), releaseTimeout); });
+            const released = await Promise.race([Promise.all(left).then(all => all.every(Boolean)), timeout]);
+            clearTimeout(timer);
+            const disposed = new Error("The world is disposed.");
+            for (const slot of slots) kill(slot, disposed);
+            await Promise.all(slots.map(slot => slot.port.terminate()));
+            if (!released) return;
+            for (const { offset, bytes } of lines) arena.free(offset, bytes);
+            for (const { offset, bytes } of rings) arena.free(offset, bytes);
+            freeArray(arena, payloads);
+        },
+    };
+};