@adobe/ecs 0.0.0-stage → 0.2.0

package/src/perftest/structural.ts

@@ -0,0 +1,150 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "../interface/entity/entity.js";
+import { System } from "../interface/system/system.js";
+import type { F32, U32 } from "../interface/math/index.js";
+
+// Structural changes one kind at a time: spawns, despawns, adds and removes, through main-thread systems and kernels,
+// each applied by the sync point that ends its run.
+
+export const index = Symbol("structural/index");
+export const value = Symbol("structural/value");
+export const flag = Symbol("structural/flag");
+export const amount = Symbol("structural/amount");
+export const extra = Symbol("structural/extra");
+export const spawned = Symbol("structural/spawned");
+const source1 = Symbol("structural/source1");
+const source2 = Symbol("structural/source2");
+const t0 = Symbol("structural/t0");
+const t1 = Symbol("structural/t1");
+const t2 = Symbol("structural/t2");
+const t3 = Symbol("structural/t3");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [index]: { type: U32 };
+        [value]: { type: F32 };
+        [flag]: { type: true };
+        [amount]: { type: F32 };
+        [extra]: { type: F32 };
+        [spawned]: { type: true };
+        [source1]: { type: true };
+        [source2]: { type: true };
+        [t0]: { type: true };
+        [t1]: { type: true };
+        [t2]: { type: true };
+        [t3]: { type: true };
+    }
+}
+
+
+const seeded = [
+    [index, value] as const,
+    [index, value, source1] as const,
+    [index, value, source2] as const,
+    [index, value, source1, source2] as const,
+] as const;
+const made = [index, value, spawned] as const;
+/** Every set of the four tags `t0` to `t3`, by its bits. */
+const tags = [t0, t1, t2, t3] as const;
+const sixteen = Array.from({ length: 16 }, (_, bits) => [index, value, spawned, ...tags.filter((_, bit) => (bits & (1 << bit)) !== 0)] as const);
+const several = [flag, amount, extra] as const;
+
+const counted = { type: "object", properties: { count: { type: "integer" } } } as const;
+
+/** `count` entities of one archetype, or with `sources: 4`, interleaved over four by two source tags. */
+export const seed = System.create({
+}, ({ commands }, input: { readonly count: number; readonly sources: number }) => {
+    for (let i = 0; i < input.count; i++) {
+        commands.spawn(seeded[input.sources === 1 ? 0 : i % 4])({ [index]: i, [value]: i });
+    }
+});
+
+/** `count` spawns of one archetype. */
+export const spawnBulk = System.create({}, ({ commands }, input: { readonly count: number }) => {
+    for (let i = 0; i < input.count; i++) commands.spawn(made)({ [index]: i, [value]: i });
+});
+
+/** One spawn of each of four archetypes: a run's fixed cost per spawn. */
+export const spawnSingles = System.create({}, ({ commands }) => {
+    commands.spawn(made)({ [index]: 0, [value]: 0 });
+    commands.spawn(sixteen[1])({ [index]: 1, [value]: 1 });
+    commands.spawn(sixteen[2])({ [index]: 2, [value]: 2 });
+    commands.spawn(sixteen[3])({ [index]: 3, [value]: 3 });
+});
+
+/** `count` spawns over sixteen archetypes, entity i into archetype i % 16: more component sets than spawns cache. */
+export const spawnSixteen = System.create({}, ({ commands }, input: { readonly count: number }) => {
+    for (let i = 0; i < input.count; i++) {
+        commands.spawn(sixteen[i % 16])({ [index]: i, [value]: i });
+    }
+});
+
+/** A spawn per row, from a kernel. */
+export const spawnKernel = System.create({ kernel: true, components: { with: [index], not: [spawned] } }, (row, { commands }) => {
+    commands.spawn(made)({ [index]: row[index], [value]: 0 });
+});
+
+/** Despawns every entity a spawn benchmark made. */
+export const despawnSpawned = System.create({ kernel: false, components: { with: [spawned] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+});
+
+/** Despawns every seeded entity. */
+export const despawnAll = System.create({ kernel: false, components: { with: [index], not: [spawned] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+});
+
+/** The same, from a kernel. */
+export const despawnKernel = System.create({ kernel: true, components: { with: [index], not: [spawned] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+});
+
+/** Entities `spawnOne` made, for `despawnOne`. */
+const pending: Entity[] = [];
+
+export const spawnOne = System.create({}, ({ commands }) => {
+    pending.push(commands.spawn(made)({ [index]: 0, [value]: 0 }));
+});
+
+/** Despawns one entity: a run's fixed cost per despawn. */
+export const despawnOne = System.create({}, ({ commands }) => {
+    const entity = pending.pop();
+    if (entity !== undefined) commands.despawn(entity);
+});
+
+export const addFlag = System.create({ kernel: false, components: { with: [index], not: [flag, spawned] } }, (row, { commands }) => {
+    commands.add(row.entity, flag);
+});
+
+export const removeFlag = System.create({ kernel: false, components: { with: [flag] } }, (row, { commands }) => {
+    commands.remove(row.entity, flag);
+});
+
+export const addFlagKernel = System.create({ kernel: true, components: { with: [index], not: [flag, spawned] } }, (row, { commands }) => {
+    commands.add(row.entity, flag);
+});
+
+export const removeFlagKernel = System.create({ kernel: true, components: { with: [flag] } }, (row, { commands }) => {
+    commands.remove(row.entity, flag);
+});
+
+export const addAmount = System.create({ kernel: false, components: { with: [index], not: [amount, spawned] } }, (row, { commands }) => {
+    commands.add(row.entity, amount, row[index]);
+});
+
+export const removeAmount = System.create({ kernel: false, components: { with: [amount] } }, (row, { commands }) => {
+    commands.remove(row.entity, amount);
+});
+
+/** Adds a value every row already has: no archetype moves, only values replaced and marked changed. */
+export const replaceAmount = System.create({ kernel: false, components: { with: [amount] } }, (row, { commands }) => {
+    commands.add(row.entity, amount, row[amount] + 1);
+});
+
+export const addSeveral = System.create({ kernel: false, components: { with: [index], not: [flag, spawned] } }, (row, { commands }) => {
+    commands.add(row.entity, several, { [amount]: row[index], [extra]: 1 });
+});
+
+export const removeSeveral = System.create({ kernel: false, components: { with: [flag, amount, extra] } }, (row, { commands }) => {
+    commands.remove(row.entity, several);
+});

package/src/perftest/suite.perf-browser-test.ts

@@ -0,0 +1,136 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { it } from "vitest";
+import { gpuDevice } from "../interface/resources/gpu-device.js";
+import { createWorld } from "../implementation/world/create.js";
+import { calibrationSource, copyBandwidth, environmentLine, resultLine, threadsBandwidth, type Benchmark, type Curve } from "./benchmark.js";
+import { gpuForest, place } from "./hierarchy.js";
+import { workers } from "../interface/resources/workers.js";
+import { loopTickIdle, loopTicks } from "./loop.js";
+import { main, placed, pooled, threads, upOperation } from "./placed.js";
+import { wake } from "./wake.js";
+import { remoteBenchmarks } from "./remote.js";
+import { logBenchmarks } from "./log.js";
+import { handoffBenchmarks } from "./handoff.js";
+import { finalizedBenchmarks } from "./finalized.js";
+import { tailBenchmarks } from "./tails.js";
+import { transferBenchmarks } from "./transfers.js";
+import { indexBenchmarks } from "./indexes.js";
+import { structReplace, valueBenchmarks } from "./values.js";
+import { observedGpuBenchmarks } from "./observed-gpu.js";
+import { uploadBenchmarks } from "./uploads.js";
+import { renderOrderBenchmarks } from "./render-order.js";
+
+/** Every worker's copy bandwidth together, through browser workers running the calibration script. */
+const browserThreadsBandwidth = async (): Promise<Curve> => {
+    const url = URL.createObjectURL(new Blob([calibrationSource], { type: "text/javascript" }));
+    try {
+        return await threadsBandwidth(threads, () => {
+            const worker = new Worker(url);
+            return {
+                ask: message => new Promise(resolve => {
+                    worker.onmessage = resolve;
+                    worker.postMessage(message);
+                }),
+                terminate: () => worker.terminate(),
+            };
+        });
+    }
+    finally {
+        URL.revokeObjectURL(url);
+    }
+};
+
+const requestDevice = async (): Promise<GPUDevice> => {
+    const adapter = await navigator.gpu.requestAdapter();
+    if (adapter === null) throw new Error("No WebGPU adapter.");
+    return adapter.requestDevice();
+};
+
+/** Bytes per nanosecond the GPU copies between buffers, read and written. */
+const gpuBandwidth = async (device: GPUDevice): Promise<number> => {
+    const bytes = 1 << 27;
+    const from = device.createBuffer({ size: bytes, usage: GPUBufferUsage.COPY_SRC });
+    const to = device.createBuffer({ size: bytes, usage: GPUBufferUsage.COPY_DST });
+    const copies = 10;
+    let best = Infinity;
+    for (let i = 0; i < 6; i++) {
+        const encoder = device.createCommandEncoder();
+        for (let k = 0; k < copies; k++) encoder.copyBufferToBuffer(from, 0, to, 0, bytes);
+        const start = performance.now();
+        device.queue.submit([encoder.finish()]);
+        await device.queue.onSubmittedWorkDone();
+        best = Math.min(best, performance.now() - start);
+    }
+    from.destroy();
+    to.destroy();
+    return (2 * bytes * copies) / (best * 1e6);
+};
+
+/** Milliseconds per run on the GPU: runs submitted back to back, timed until the GPU finishes them. */
+const gpuFastest = async (device: GPUDevice, run: () => Promise<unknown>, batch = 20): Promise<number> => {
+    for (let i = 0; i < batch; i++) await run();
+    await device.queue.onSubmittedWorkDone();
+    let best = Infinity;
+    for (let round = 0; round < 10; round++) {
+        const start = performance.now();
+        for (let i = 0; i < batch; i++) await run();
+        await device.queue.onSubmittedWorkDone();
+        best = Math.min(best, (performance.now() - start) / batch);
+    }
+    return best;
+};
+
+const benchmarks = (device: GPUDevice): readonly Benchmark[] => [
+    ...placed([main, pooled]),
+    ...indexBenchmarks.filter(benchmark => benchmark.name.endsWith(" workers")),
+    ...valueBenchmarks,
+    structReplace("main", 0),
+    structReplace("workers", threads, "threads"),
+    wake,
+    {
+        name: "loop tick idle",
+        operation: "A world's loop ticking with nothing changed, driven back to back with `always` set, counted by an observer system reading its clock: the fixed cost of every tick.",
+        per: "ticks",
+        n: loopTicks,
+        typical: [1, 1],
+        best: { bytes: 64, basis: "A run reads at least one cache line of its system's state." },
+        run: () => loopTickIdle(),
+    },
+    ...remoteBenchmarks,
+    ...logBenchmarks,
+    ...handoffBenchmarks,
+    ...finalizedBenchmarks,
+    ...tailBenchmarks,
+    ...transferBenchmarks,
+    ...observedGpuBenchmarks(device, run => gpuFastest(device, run)),
+    ...uploadBenchmarks(device, run => gpuFastest(device, run)),
+    ...renderOrderBenchmarks(device, run => gpuFastest(device, run)),
+    ...[[100_000, 10, "100K chains of 10"], [1_000, 1_000, "1K chains of 1,000"]].map(([roots, depth, chains]): Benchmark => ({
+        name: `up depth ${depth} gpu`,
+        operation: upOperation(String(chains)),
+        per: "rows",
+        n: 1_000_000,
+        typical: [1_000, 100_000],
+        best: { bytes: 16, basis: "Each row reads its 4-byte value, its parent's 4-byte result and 4-byte row, and writes its 4-byte result.", on: "gpu" },
+        run: async () => {
+            const world = createWorld({ [workers]: 0, [gpuDevice]: device });
+            try {
+                await world.run(gpuForest, { roots: Number(roots), depth: Number(depth) });
+                return await gpuFastest(device, () => world.run(place));
+            } finally {
+                await world.dispose();
+            }
+        },
+    })),
+];
+
+it("runs the browser benchmarks", async () => {
+    const device = await requestDevice();
+    console.log(environmentLine(navigator.userAgent.match(/Chrome\/[\d.]+/)?.[0].replace("/", " ") ?? navigator.userAgent, {
+        thread: copyBandwidth(),
+        threads: await browserThreadsBandwidth(),
+        gpu: await gpuBandwidth(device),
+    }));
+    for (const benchmark of benchmarks(device)) console.log(resultLine(benchmark, await benchmark.run()));
+    device.destroy();
+}, 600_000);

package/src/perftest/suite.perf-test.ts

@@ -0,0 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { it } from "vitest";
+import { benchmarks } from "./benchmarks.js";
+import { report } from "./suite.js";
+
+// Under vitest's node transform every imported binding is a getter, which inflates JS-heavy paths;
+// `pnpm perf` runs the same benchmarks bundled, on plain node.
+for (const benchmark of benchmarks) it(benchmark.name, async () => report(benchmark.name, await benchmark.run()), 120_000);

package/src/perftest/suite.ts

@@ -0,0 +1,214 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Entity } from "../interface/entity/entity.js";
+import type { I32 } from "../interface/math/i32/index.js";
+import type { Schema } from "../interface/schema/schema.js";
+import { System } from "../interface/system/system.js";
+import type { World } from "../interface/world/world.js";
+import type { F32, U32 } from "../interface/math/index.js";
+
+// One fixture per optimization area: structural changes, change filters, lookups, commands, dispatch and main-thread
+// paths.
+
+type Vec3 = readonly [number, number, number];
+const vec3 = { type: "array", items: { type: "number", precision: 1 }, minItems: 3, maxItems: 3 } as const satisfies Schema;
+
+export const position = Symbol("suite/position");
+export const velocity = Symbol("suite/velocity");
+export const target = Symbol("suite/target");
+export const index = Symbol("suite/index");
+export const tag = Symbol("suite/tag");
+export const unused = Symbol("suite/unused");
+export const hits = Symbol("suite/hits");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [position]: { type: Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }> };
+        [velocity]: { type: Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }> };
+        [target]: { type: Entity };
+        [index]: { type: U32 };
+        [tag]: { type: true };
+        [unused]: { type: true };
+        [hits]: { type: F32 };
+    }
+}
+
+export const indexSum = Symbol("suite/indexSum");
+export const highest = Symbol("suite/highest");
+declare module "@adobe/ecs" {
+    export interface Resources {
+        [indexSum]: { type: number; reduce: "+" };
+        [highest]: { type: number; reduce: "max" };
+    }
+}
+
+
+const moving = [position, velocity, index] as const;
+const following = [position, velocity, index, target] as const;
+
+/** `count` entities, each targeting the one spawned before it. */
+export const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
+    let previous = commands.spawn(moving)({ [position]: [0, 0, 0], [velocity]: [0, 0, 0], [index]: 0 });
+    for (let i = 1; i < input.count; i++) {
+        previous = commands.spawn(following)({ [position]: [i, i * 0.5, -i], [velocity]: [1, 0, 0], [index]: i, [target]: previous });
+    }
+});
+
+/** Despawns a tenth of the entities and spawns as many replacements. */
+export const churn = System.create({ components: { with: [index, position] } }, (row, { commands }, input: { readonly group: number }) => {
+    if (row[index] % 10 !== input.group) return;
+    commands.despawn(row.entity);
+    commands.spawn(moving)({ [position]: row[position], [velocity]: [0, 0, 0], [index]: row[index] });
+});
+
+/** Adds the tag to one tenth and removes it from another: a fifth of the entities move archetype. */
+export const retag = System.create({ components: { with: [index] } }, (row, { commands }, input: { readonly group: number }) => {
+    const group = row[index] % 10;
+    if (group === input.group) commands.add(row.entity, tag);
+    else if (group === (input.group + 5) % 10) commands.remove(row.entity, tag);
+});
+
+/** Writes 1% of positions. */
+export const poke = System.create({
+    kernel: true,
+    components: { with: [index, position] },
+}, (row, _context, input: { readonly group: I32 }) => {
+    if (row[index] % 100 === input.group) {
+        const [x, y, z] = row[position];
+        row[position] = [x + 1, y, z];
+    }
+});
+
+/** Writes 1% of positions, clustered in one contiguous run of rows. */
+export const pokeCluster = System.create({
+    kernel: true,
+    components: { with: [index, position] },
+}, (row, _context, input: { readonly group: I32 }) => {
+    const group = row[index] - input.group * 10_000;
+    if (group >= 0 && group < 10_000) {
+        const [x, y, z] = row[position];
+        row[position] = [x + 1, y, z];
+    }
+});
+
+/** Sees only what changed since it last ran. */
+export const observe = System.create({
+    kernel: true,
+    components: { with: [position, velocity], changed: [position] },
+}, row => {
+    const [x, y, z] = row[position];
+    row[velocity] = [x * 0.5, y * 0.5, z * 0.5];
+});
+
+/** Steers toward the target: one lookup per row. */
+export const follow = System.create({
+    kernel: true,
+    components: { with: [position, target, velocity] },
+    lookup: { targets: { with: [position] } },
+}, (row, { lookup: { targets } }) => {
+    const other = targets(row[target]);
+    if (other !== null) {
+        const [tx, ty, tz] = other[position];
+        const [x, y, z] = row[position];
+        row[velocity] = [tx - x, ty - y, tz - z];
+    }
+});
+
+/** Issues commands from a kernel: a tenth of the rows record a hit. */
+export const emit = System.create({
+    kernel: true,
+    components: { with: [index, position] },
+}, (row, { commands }) => {
+    if (row[index] % 10 === 0) {
+        const [x] = row[position];
+        commands.add(row.entity, hits, x);
+    }
+});
+
+/** Six dependent kernels: one tier each, so dispatch cost shows. */
+export const chain1 = System.create({ kernel: true, components: { with: [velocity] } }, row => {
+    const [x, y, z] = row[velocity];
+    row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
+});
+export const chain2 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain1] }, row => {
+    const [x, y, z] = row[velocity];
+    row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
+});
+export const chain3 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain2] }, row => {
+    const [x, y, z] = row[velocity];
+    row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
+});
+export const chain4 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain3] }, row => {
+    const [x, y, z] = row[velocity];
+    row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
+});
+export const chain5 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain4] }, row => {
+    const [x, y, z] = row[velocity];
+    row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
+});
+export const chain6 = System.create({ kernel: true, components: { with: [velocity] }, after: [chain5] }, row => {
+    const [x, y, z] = row[velocity];
+    row[velocity] = [x * 0.99, y * 0.99, z * 0.99];
+});
+export const chain = System.create({ systems: [chain1, chain2, chain3, chain4, chain5, chain6] });
+
+/** Fifty small main-thread systems in one tier, each reading every row. */
+let total = 0;
+export const smalls = System.create({
+    systems: Array.from({ length: 50 }, (_, i) => System.create({ components: { with: [position] } }, row => {
+        total += row[position][0];
+    })),
+});
+export const totalOf = (): number => total;
+
+/** Fastest of repeated runs within a time budget, like the adobe/data harness. */
+export const fastest = async (run: () => Promise<unknown>, budget = 1000, warmup = 10): Promise<number> => {
+    for (let warm = 0; warm < warmup; warm++) await run();
+    let minimum = Infinity;
+    const end = performance.now() + budget;
+    while (performance.now() < end) {
+        const start = performance.now();
+        await run();
+        minimum = Math.min(minimum, performance.now() - start);
+    }
+    return minimum;
+};
+
+/** One line per benchmark, so runs can be compared with grep. */
+export const report = (name: string, milliseconds: number): void => {
+    console.log(`bench ${name}: ${milliseconds.toFixed(3)} ms`);
+};
+
+/** A world seeded with `count` entities. Systems register on their first run, which `fastest` leaves out. */
+export const seeded = async (create: () => World, count: number): Promise<World> => {
+    const world = create();
+    await world.run(seed, { count });
+    return world;
+};
+
+/** Folds every row's index into a sum and a maximum. */
+export const reduce = System.create({ kernel: true, components: { with: [index] } }, (row, { reduce }) => {
+    reduce[indexSum](row[index]);
+    reduce[highest](row[index]);
+});
+
+/** A system no entity matches: what a run costs with nothing to do. */
+export const idle = System.create({ components: { with: [unused] } }, () => {});
+/** A system that throws, so each run of it rejects. */
+export const failing = System.create({}, () => { throw new Error("suite: failing"); });
+/** An observer system no entity matches: a run of it alone has no tiers. */
+export const idleObserver = System.create({ observer: true, components: { with: [unused] } }, () => {});
+
+/** Fifty systems no entity matches, in one tier. */
+export const idles = System.create({
+    systems: Array.from({ length: 50 }, (_, i) => System.create({ components: { with: [unused] } }, () => {})),
+});
+
+/** Spawns one entity: a run with a sync point that applies one command. */
+export const spawnOne = System.create({}, ({ commands }) => {
+    commands.spawn(moving)({ [position]: [0, 0, 0], [velocity]: [0, 0, 0], [index]: 0 });
+});
+
+/** One main-thread system reading every row. */
+export const small = System.create({ components: { with: [position] } }, row => {
+    total += row[position][0];
+});

package/src/perftest/systems.ts

@@ -0,0 +1,132 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { always } from "../interface/resources/always.js";
+import { eachTick, ticksAfter } from "./observer.js";
+import { System } from "../interface/system/system.js";
+import { backToBack, createWorld } from "../implementation/index.js";
+import type { Benchmark } from "./benchmark.js";
+import { idle } from "./suite.js";
+
+// Benchmarks of systems added to ticks and removed again while a world ticks back to back.
+
+const level = Symbol("systems/level");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [level]: { type: number };
+    }
+}
+
+/** Entities the added systems read. */
+const entities = 100;
+
+const seed = System.create({}, ({ commands }) => {
+    for (let i = 0; i < entities; i++) commands.spawn([level])({ [level]: i });
+});
+
+let read = 0;
+
+/** A new system for each tick: a change filter, which counts as watching `level`, and rows to read. */
+const fresh = (): System => System.create({ components: { with: [level], changed: [level] } }, row => { read += row[level]; });
+
+/** One module's system, added and removed again and again. */
+const again = System.create({ components: { with: [level], changed: [level] } }, row => { read += row[level]; });
+
+/** Ticks in each timed stretch. */
+export const churnTicks = 10_000;
+
+const check = (condition: boolean, message: string): void => {
+    if (!condition) throw new Error(message);
+};
+
+/**
+ * The fastest of `stretches` stretches of `churnTicks` ticks, after one to warm up, of a world with `idle` added and,
+ * with `churn`, a system made for each tick added to the next and removed from the one after, by an observer system
+ * reading its clock; then, with `after`, ticks with nothing added or removed. What the world holds is the same before
+ * and after.
+ */
+const churning = async (churn: (() => System) | null, after: boolean, stretches = 5): Promise<number> => {
+    const driver = backToBack();
+    const world = createWorld({ [always]: true }, { loop: driver });
+    let best = Infinity;
+    try {
+        await world.run(seed);
+        world.add(idle);
+        // Once a system with the filter came and went, ticks are kept for what it filters on, and the loop's state is
+        // added.
+        world.add(again);
+        await ticksAfter(world, 2);
+        world.remove(again);
+        await world.run(idle);
+        const before = await world.tables();
+        let added: System | null = null;
+        const stretch = (churned: (() => System) | null): Promise<void> => new Promise<void>(resolve => {
+            let ticks = 0;
+            let stretched = 0;
+            let start = 0;
+            const unobserve = eachTick(world, () => {
+                if (churned !== null) {
+                    if (added !== null) world.remove(added);
+                    added = churned();
+                    world.add(added);
+                }
+                if (ticks++ % churnTicks !== 0) return;
+                const now = performance.now();
+                // The first stretch warms up.
+                if (stretched > 1) best = Math.min(best, now - start);
+                start = now;
+                if (stretched++ <= stretches) return;
+                unobserve();
+                if (added !== null) world.remove(added);
+                added = null;
+                resolve();
+            });
+        });
+        if (after) {
+            await stretch(churn);
+            best = Infinity;
+            await stretch(null);
+        }
+        else await stretch(churn);
+        // A run, so what removed systems held is released before the world's tables are read.
+        await world.run(idle);
+        const held = await world.tables();
+        check(held.runners === before.runners && held.arena === before.arena && held.observed === before.observed, `systems: the world holds ${JSON.stringify(held)} after, against ${JSON.stringify(before)} before`);
+        check(read > 0 || churn === null, "systems: nothing read");
+    }
+    finally {
+        await world.dispose();
+        driver.close();
+    }
+    return best;
+};
+
+const tickBest = { bytes: 64, basis: "A tick reads at least one cache line of its systems' state." };
+
+export const systemBenchmarks: readonly Benchmark[] = [
+    {
+        name: "loop tick add remove",
+        operation: "Ticks back to back, each adding a new system with a change filter over 100 rows and removing the one the last tick added: systems that come and go with what a UI shows.",
+        per: "ticks",
+        n: churnTicks,
+        typical: [1, 1],
+        best: tickBest,
+        run: () => churning(fresh, false),
+    },
+    {
+        name: "loop tick add remove again",
+        operation: "Ticks back to back, each adding or removing one module's system with a change filter over 100 rows: a feature switched on and off.",
+        per: "ticks",
+        n: churnTicks,
+        typical: [1, 1],
+        best: tickBest,
+        run: () => churning(() => again, false),
+    },
+    {
+        name: "loop tick idle after add remove",
+        operation: "Ticks with nothing changed after 60,000 ticks that each added a new system and removed the last: what systems that came and went leave behind in every tick.",
+        per: "ticks",
+        n: churnTicks,
+        typical: [1, 1],
+        best: tickBest,
+        run: () => churning(fresh, true),
+    },
+];