@adobe/ecs 0.1.0 → 0.2.1

package/src/perftest/remote.ts

@@ -1,7 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
-import { Component } from "../interface/component/component.js";
 import { Index } from "../interface/indexes/index-type.js";
-import { Resource } from "../interface/resource/resource.js";
 import { always } from "../interface/resources/always.js";
 import { eachTick } from "./observer.js";
 import { workers } from "../interface/resources/workers.js";
@@ -28,25 +27,19 @@ declare module "@adobe/ecs" {
     }
     export interface Resources {
         [counter]: { type: number };
-        [sign]: { type: number };
+        [sign]: { type: number; default: 1 };
     }
 }
-Resource.register(counter, { type: { type: "number", default: 0 } });
-Resource.register(sign, { type: { type: "number", default: 1 } });
-Component.register(rank, { type: { type: "number" } });
-Component.register(order, { type: { type: "number" } });
-Component.register(caption, { type: { type: "string" } });
-Component.register(amount, { type: { type: "number" } });
 
 /** An empty transaction. */
-export const empty = System.create({ name: "remote/empty" }, () => {});
+export const empty = System.create({}, () => {});
 /** Changes the observed resource every tick. */
-export const count = System.create({ name: "remote/count", resources: { write: [counter] } }, ({ resources }) => { resources[counter] += 1; });
-export const seedRanks = System.create({ name: "remote/seedRanks", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const count = System.create({}, ({ resources }) => { resources[counter] += 1; });
+export const seedRanks = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) commands.spawn([rank, order])({ [rank]: i, [order]: i });
 });
-const flip = System.create({ name: "remote/flip", resources: { write: [sign] } }, ({ resources }) => { resources[sign] = -resources[sign]; });
-const reverse = System.create({ name: "remote/reverse", kernel: "cpu", components: { read: [rank], write: [order] }, resources: { read: [sign] }, after: [flip] }, (row, { resources }) => {
+const flip = System.create({}, ({ resources }) => { resources[sign] = -resources[sign]; });
+const reverse = System.create({ kernel: true, components: { with: [rank, order] }, after: [flip] }, (row, { resources }) => {
     row[order] = row[rank] * resources[sign];
 });
 /** Reverses the entities' order every tick. */
@@ -56,19 +49,19 @@ export const reorder = System.create([flip, reverse]);
 export const observerSeen = { last: 0, notified: 0 };
 
 /** On a joined thread, after each sync point that changed it: the observed resource. */
-export const observerCounter = System.create({ name: "remote/observerCounter", observer: true, resources: { read: [counter], changed: [counter] } }, ({ resources }) => {
+export const observerCounter = System.create({ observer: true, resources: { changed: [counter] } }, ({ resources }) => {
     observerSeen.last = resources[counter];
     observerSeen.notified++;
 });
 
 /** Every entity with a rank, in entity order. */
-const ranked = Index.create({ name: "remote/ranked", key: [], components: { has: [rank, order] } });
+const ranked = Index.create({ key: [], components: { with: [rank, order] } });
 const sortedKeys = { keys: new Float64Array(0), entities: new Float64Array(0), positions: new Uint32Array(0) };
 /**
  * On a joined thread, after each sync point: the entities in `order`, sorted from a scan of the index of every ranked
  * entity into reused arrays.
  */
-export const observerSelect = System.create({ name: "remote/observerSelect", observer: true, lookup: { all: { index: ranked, read: [order] } } }, ({ lookup }) => {
+export const observerSelect = System.create({ observer: true, lookup: { all: { index: ranked } } }, ({ lookup }) => {
     const list = lookup.all();
     const count = list.length;
     if (sortedKeys.keys.length < count) {
@@ -91,13 +84,13 @@ export const observerSelect = System.create({ name: "remote/observerSelect", obs
 });
 
 /** Rows with a caption and an amount, a todo's label and a number, which `retext` and `reamount` rewrite 1% of a tick. */
-export const seedCaptions = System.create({ name: "remote/seedCaptions", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const seedCaptions = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) commands.spawn([rank, caption, amount])({ [rank]: i, [caption]: `Buy milk and bread #${i}`, [amount]: i });
 });
-const recaption = System.create({ name: "remote/recaption", components: { read: [rank], write: [caption] }, resources: { read: [counter] }, after: [count] }, (row, { resources }) => {
+const recaption = System.create({ components: { with: [rank, caption] }, after: [count] }, (row, { resources }) => {
     if (row[rank] % 100 === resources[counter] % 100) row[caption] = `Buy milk and bread #${row[rank]}.${resources[counter]}`;
 });
-const reamount = System.create({ name: "remote/reamount", components: { read: [rank], write: [amount] }, resources: { read: [counter] }, after: [count] }, (row, { resources }) => {
+const reamount = System.create({ kernel: false, components: { with: [rank, amount] }, after: [count] }, (row, { resources }) => {
     if (row[rank] % 100 === resources[counter] % 100) row[amount] = row[rank] + resources[counter];
 });
 /** Rewrites 1% of the captions a tick. */
@@ -106,12 +99,12 @@ export const retext = System.create([count, recaption]);
 export const reamounted = System.create([count, reamount]);
 
 /** On a joined thread, after each sync point: every row's caption, out of its record. */
-export const observerCaptions = System.create({ name: "remote/observerCaptions", observer: true, components: { read: [caption] } }, row => {
+export const observerCaptions = System.create({ observer: true, components: { with: [caption] } }, row => {
     observerSeen.last += row[caption].length;
     observerSeen.notified++;
 });
 /** On a joined thread, after each sync point: every row's amount. */
-export const observerAmounts = System.create({ name: "remote/observerAmounts", observer: true, components: { read: [amount] } }, row => {
+export const observerAmounts = System.create({ observer: true, components: { with: [amount] } }, row => {
     observerSeen.last += row[amount];
     observerSeen.notified++;
 });
@@ -136,7 +129,7 @@ const joinedFile = "./joined.js";
 /** The observed resource, read by an observer run. */
 const counterOf = async (world: World): Promise<number> => {
     let value = 0;
-    await world.run(System.create({ observer: true, resources: { read: [counter] } }, ({ resources }) => { value = resources[counter]; }));
+    await world.run(System.create({ observer: true }, ({ resources }) => { value = resources[counter]; }));
     return value;
 };
 
@@ -144,24 +137,26 @@ const counterOf = async (world: World): Promise<number> => {
 const startJoined = async (world: World): Promise<Joined> => {
     if (typeof globalThis.Worker === "function") {
         const { port1, port2 } = new MessageChannel();
-        world.share(port1);
+        const shared = world.share(port1);
         const worker = new globalThis.Worker(new URL("./joined.js", import.meta.url), { type: "module" });
         const ask = (message: unknown, transfer: Transferable[] = []): Promise<FromJoined> => new Promise(resolve => {
             worker.onmessage = (event: MessageEvent<FromJoined>) => resolve(event.data);
             worker.postMessage(message, transfer);
         });
         await ask({ kind: "port", port: port2 }, [port2]);
+        await shared;
         return { ask, terminate: async () => worker.terminate() };
     }
     const threads = globalThis.process.getBuiltinModule("node:worker_threads");
     const { port1, port2 } = new threads.MessageChannel();
-    world.share(port1);
+    const shared = world.share(port1);
     const worker = new threads.Worker(new URL(joinedFile, import.meta.url));
     const ask = (message: unknown, transfer: readonly import("node:worker_threads").Transferable[] = []): Promise<FromJoined> => new Promise(resolve => {
         worker.once("message", resolve);
         worker.postMessage(message, transfer);
     });
     await ask({ kind: "port", port: port2 }, [port2]);
+    await shared;
     return { ask, terminate: async () => { await worker.terminate(); } };
 };
 
@@ -174,8 +169,9 @@ const remoteRun = async (stretches = 5): Promise<number> => {
         return reply.kind === "ran" ? reply.milliseconds : NaN;
     }
     finally {
-        await joined.terminate();
+        // Disposed first: ticks after the thread ended would fail its systems, reported out of band.
         await world.dispose();
+        await joined.terminate();
     }
 };
 
@@ -216,8 +212,9 @@ const joinedBest = async (kind: Observed, system: System<void>, stretches = 5):
         if (reads && stopped.last < counted - joinedTicks) throw new Error(`joined ${kind}: the joined thread saw ${stopped.last} of ${counted}.`);
     }
     finally {
-        await joined.terminate();
+        // Disposed first: ticks after the thread ended would fail its systems, reported out of band.
         await world.dispose();
+        await joined.terminate();
         driver.close();
     }
     return best;
@@ -279,8 +276,9 @@ const cadenceMiddle = async (kind: Observed, system: System<void>): Promise<numb
         if (stopped.kind !== "stopped" || stopped.last < counted - 2) throw new Error(`${kind} at a cadence: the joined thread saw ${stopped.kind === "stopped" ? stopped.last : "nothing"} of ${counted}.`);
     }
     finally {
-        await joined.terminate();
+        // Disposed first: ticks after the thread ended would fail its systems, reported out of band.
         await world.dispose();
+        await joined.terminate();
     }
     spent.sort();
     let middle = 0;

package/src/perftest/render-order.ts

@@ -0,0 +1,86 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Entity } from "../interface/entity/entity.js";
+import { Index } from "../interface/indexes/index-type.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 } from "../implementation/world/create.js";
+import type { Benchmark } from "./benchmark.js";
+import type { F32 } from "../interface/math/index.js";
+
+// A 2D editor's paint order: shapes and images, two archetypes, interleaved in depth, drawn as one table in a sorted
+// index's order.
+
+const paintDepth = Symbol("renderOrder/paintDepth");
+const shape = Symbol("renderOrder/shape");
+const image = Symbol("renderOrder/image");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [paintDepth]: { type: F32 };
+        [shape]: { type: true };
+        [image]: { type: true };
+    }
+}
+
+const byDepth = Index.create({ key: [paintDepth], sorted: true });
+
+const items = 50_000;
+let spawned: Entity[] = [];
+const spawn = System.create({}, ({ commands }) => {
+    spawned = [];
+    for (let i = 0; i < items; i++) {
+        spawned.push(i % 2 === 0 ? commands.spawn([paintDepth, shape])({ [paintDepth]: i, [shape]: true }) : commands.spawn([paintDepth, image])({ [paintDepth]: i, [image]: true }));
+    }
+});
+/** Moves one item to a new depth, as reordering it does. */
+const restack = System.create({
+    components: { with: [paintDepth] },
+    target: "item",
+}, (row, _context, input: { readonly item: Entity; readonly depth: number }) => {
+    row[paintDepth] = input.depth;
+});
+/** Draws nothing: its run uploads what it reads and its order. */
+const draw = System.render({ order: byDepth, shader: { accessors: { paintDepth } }, after: [restack] }, () => {});
+const frame = System.create({ systems: [restack, draw] });
+
+/** Timed per run by `timed`, which waits for the GPU. */
+export const renderOrderBenchmarks = (device: GPUDevice, timed: (run: () => Promise<unknown>) => Promise<number>): readonly Benchmark[] => [{
+    name: "gpu ordered render unchanged 50K",
+    operation: "A render system with an order over 50K shapes and images, two archetypes interleaved in depth, run with nothing changed: it uploads nothing and writes neither its order nor its record.",
+    per: "runs",
+    n: 1,
+    typical: [1, 1],
+    best: { bytes: 64, basis: "A run reads at least one cache line of its system's state." },
+    run: async () => {
+        const world = createWorld({ [workers]: 0, [gpuDevice]: device });
+        try {
+            await world.run(spawn);
+            await world.run(draw);
+            return await timed(() => world.run(draw));
+        }
+        finally {
+            await world.dispose();
+        }
+    },
+}, {
+    name: "gpu ordered render one key 50K",
+    operation: "A target system moving one of 50K shapes and images to another depth, then a render system ordered by depth, which refreshes the index, lists the 50K in order and writes them, 200 KB.",
+    per: "runs",
+    n: 1,
+    typical: [1, 1],
+    best: { bytes: 400_000, basis: "The order's 50K 4-byte entries are written on the CPU and again by the upload.", on: "gpu" },
+    run: async () => {
+        const world = createWorld({ [workers]: 0, [gpuDevice]: device });
+        try {
+            await world.run(spawn);
+            const item = spawned[items / 2];
+            let depth = 0.5;
+            await world.run(frame, { item, depth });
+            // Between two others each time, so its place in the order moves.
+            return await timed(() => world.run(frame, { item, depth: depth = (depth + 1009) % items }));
+        }
+        finally {
+            await world.dispose();
+        }
+    },
+}];

package/src/perftest/run.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
 import { calibrationSource, copyBandwidth, environmentLine, resultLine, threadsBandwidth, type Curve } from "./benchmark.js";
 import { benchmarks } from "./benchmarks.js";

package/src/perftest/shared.ts

@@ -0,0 +1,416 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Entity } from "../interface/entity/entity.js";
+import type { Vec2 } from "../interface/math/index.js";
+import { workers } from "../interface/resources/workers.js";
+import { System } from "../interface/system/system.js";
+import { createWorld } from "../implementation/index.js";
+import type { Benchmark } from "./benchmark.js";
+import { fastest } from "./suite.js";
+
+// Shared components: a row reading its archetype's value against one reading a column, in a body and a kernel;
+// spawning with a shared constant against spawning without one; `where` culling cells to a camera's view, still and
+// moving; and many small archetypes, one per value, against one archetype holding the same rows with a column.
+
+const height = Symbol("shared/height");
+const lift = Symbol("shared/lift");
+const level = Symbol("shared/level");
+const cell = Symbol("shared/cell");
+const value = Symbol("shared/value");
+const group = Symbol("shared/group");
+const camera = Symbol("shared/camera");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [height]: { type: number };
+        [lift]: { type: number };
+        // `lift`'s value, shared.
+        [level]: { type: number; shared: true };
+        [cell]: { type: Vec2.I32; shared: true };
+        [value]: { type: number };
+        // An archetype's number, as a column: the baseline for archetypes told apart by `cell`.
+        [group]: { type: number };
+    }
+    export interface Resources {
+        [camera]: { type: { readonly x: number; readonly y: number; readonly radius: number }; default: { x: 0; y: 0; radius: 1 } };
+    }
+}
+
+const rows = 100_000;
+
+// Reads: 100K rows in one archetype, lifted by a column or by the archetype's shared value.
+const seedReads = System.create({}, ({ commands }) => {
+    const shared = commands.spawn([height, level], { [level]: 1 });
+    for (let i = 0; i < rows; i++) {
+        commands.spawn([height, lift])({ [height]: 0, [lift]: 1 });
+        shared({ [height]: 0 });
+    }
+});
+const raiseShared = System.create({ kernel: false, components: { with: [height, level] } }, row => {
+    row[height] += row[level];
+});
+const raiseSharedKernel = System.create({ kernel: true, components: { with: [height, level] } }, row => {
+    row[height] += row[level];
+});
+const raiseColumn = System.create({ kernel: false, components: { with: [height, lift] } }, row => {
+    row[height] += row[lift];
+});
+const raiseColumnKernel = System.create({ kernel: true, components: { with: [height, lift] } }, row => {
+    row[height] += row[lift];
+});
+
+const reads = async (system: System<void>): Promise<number> => {
+    const world = createWorld({ [workers]: 0 });
+    await world.run(seedReads);
+    const best = await fastest(() => world.run(system));
+    await world.dispose();
+    return best;
+};
+
+// Spawns: one entity into each of four cells, by a spawner with a shared constant each, against four archetypes of
+// columns; and 100K into one cell.
+const spawnPreset = System.create(({ commands }) => {
+    for (let k = 0; k < 4; k++) commands.spawn([cell, value], { [cell]: [k, 0] })({ [value]: k });
+});
+const spawnPlain = System.create(({ commands }) => {
+    commands.spawn([value])({ [value]: 0 });
+    commands.spawn([value, height])({ [value]: 1, [height]: 0 });
+    commands.spawn([value, lift])({ [value]: 2, [lift]: 0 });
+    commands.spawn([value, group])({ [value]: 3, [group]: 0 });
+});
+const spawnBulkPreset = System.create(({ commands }) => {
+    const spawn = commands.spawn([cell, value], { [cell]: [0, 0] });
+    for (let i = 0; i < rows; i++) spawn({ [value]: i });
+});
+const spawnBulkPlain = System.create(({ commands }) => {
+    for (let i = 0; i < rows; i++) commands.spawn([value, group])({ [value]: i, [group]: 0 });
+});
+const despawnValues = System.create({ components: { with: [value] } }, (row, { commands }) => { commands.despawn(row.entity); });
+
+const spawns = async (system: System<void>, bulk: boolean): Promise<number> => {
+    const world = createWorld({ [workers]: 0 });
+    let best = Infinity;
+    if (!bulk) best = await fastest(() => world.run(system));
+    else {
+        for (let k = 0; k < 12; k++) {
+            const start = performance.now();
+            await world.run(system);
+            best = Math.min(best, performance.now() - start);
+            await world.run(despawnValues);
+        }
+    }
+    await world.dispose();
+    return best;
+};
+
+// Culling: 1K cells of 32 × 32, ten rows each, a system over the cells within a camera's view, 3 × 3 of them.
+const side = 32;
+const perCell = 10;
+const seedCells = System.create(({ commands }) => {
+    for (let x = 0; x < side; x++) {
+        for (let y = 0; y < side; y++) {
+            const spawn = commands.spawn([cell, value], { [cell]: [x, y] });
+            for (let k = 0; k < perCell; k++) spawn({ [value]: k });
+        }
+    }
+});
+const pan = System.create(({ resources }) => {
+    const { x } = resources[camera];
+    resources[camera] = { x: x >= side - 2 ? 1 : x + 1, y: 16, radius: 1 };
+});
+const visit = System.create({
+    kernel: false,
+    after: [pan],
+    components: { with: [value], where: { [cell]: (at, { resources }) => Math.max(Math.abs(at[0] - resources[camera].x), Math.abs(at[1] - resources[camera].y)) <= resources[camera].radius } },
+}, row => {
+    row[value] += 1;
+});
+const still = System.create([visit]);
+const moving = System.create({ systems: [pan, visit] });
+
+const culling = async (system: System<void>): Promise<number> => {
+    const world = createWorld({ [workers]: 0 });
+    await world.run(seedCells);
+    const best = await fastest(() => world.run(system));
+    await world.dispose();
+    return best;
+};
+
+// Culling with a change filter: the same cells, 1% of rows moving to the next cell along x with a new value before each
+// run, so a system with `where` and `changed` sees what moved into its view; against the same filter without `where`.
+const movers = Math.round(side * side * perCell / 100);
+const placed: { entity: Entity; x: number; y: number; value: number }[] = [];
+let moved = 0;
+const seedMovers = System.create(({ commands }) => {
+    placed.length = moved = 0;
+    for (let x = 0; x < side; x++) {
+        for (let y = 0; y < side; y++) {
+            const spawn = commands.spawn([cell, value], { [cell]: [x, y] });
+            for (let k = 0; k < perCell; k++) placed.push({ entity: spawn({ [value]: k }), x, y, value: k });
+        }
+    }
+});
+const drift = System.create(({ commands }) => {
+    for (let k = 0; k < movers; k++) {
+        const at = placed[(moved++ * 101) % placed.length];
+        at.x = (at.x + 1) % side;
+        at.value++;
+        commands.add(at.entity, cell, [at.x, at.y]);
+        commands.add(at.entity, value, at.value);
+    }
+});
+let seenChanged = 0;
+const seeChanged = System.create({
+    kernel: false,
+    components: { with: [value], changed: [value], where: { [cell]: (at, { resources }) => Math.max(Math.abs(at[0] - resources[camera].x), Math.abs(at[1] - resources[camera].y)) <= resources[camera].radius } },
+}, () => { seenChanged++; });
+const seeChangedEverywhere = System.create({ kernel: false, components: { with: [value], changed: [value] } }, () => { seenChanged++; });
+
+/** The fastest of a system's runs, each after a run of `drift` and its sync point, the camera `radius` cells wide. */
+const drifting = async (system: System<void>, radius: number): Promise<number> => {
+    const world = createWorld({ [workers]: 0 });
+    await world.run(seedMovers);
+    await world.run(System.create(({ resources }) => { resources[camera] = { x: 16, y: 16, radius }; }));
+    let best = Infinity;
+    for (let k = 0; k < 400; k++) {
+        await world.run(drift);
+        const start = performance.now();
+        await world.run(system);
+        best = Math.min(best, performance.now() - start);
+    }
+    await world.dispose();
+    return best;
+};
+
+// Walking: one entity moving to a new cell each run, 100K cells, each cell's archetype emptied as it leaves, then a
+// system over one row; against the same system before the walk. And an entity crossing between two cells each run.
+let walker = Entity.none;
+const seedWalker = System.create(({ commands }) => {
+    walker = commands.spawn([cell, value], { [cell]: [0, 0] })({ [value]: 0 });
+});
+const walkTo = System.create({}, ({ commands }, input: { readonly x: number }) => { commands.add(walker, cell, [input.x, 0]); });
+const touchOne = System.create({ kernel: false, components: { with: [value] } }, row => { row[value] += 1; });
+
+const walking = async (cells: number): Promise<number> => {
+    const world = createWorld({ [workers]: 0 });
+    await world.run(seedWalker);
+    for (let x = 1; x <= cells; x++) await world.run(walkTo, { x });
+    const best = await fastest(() => world.run(touchOne));
+    await world.dispose();
+    return best;
+};
+
+/** The fastest run moving the walker to a cell it never visited, and its sync point. */
+const walkingOn = async (): Promise<number> => {
+    const world = createWorld({ [workers]: 0 });
+    await world.run(seedWalker);
+    let x = 1;
+    const best = await fastest(() => world.run(walkTo, { x: x++ }));
+    await world.dispose();
+    return best;
+};
+
+/** The fastest run moving the walker round `cells` cells, each left empty for `cells - 1` sync points. */
+const flickering = async (cells: number): Promise<number> => {
+    const world = createWorld({ [workers]: 0 });
+    await world.run(seedWalker);
+    let x = 0;
+    const best = await fastest(() => world.run(walkTo, { x: x++ % cells }));
+    await world.dispose();
+    return best;
+};
+
+// Small archetypes: 10K rows in 1K archetypes of one cell each, against the same rows in one archetype with a column.
+const seedSmall = System.create({}, ({ commands }, input: { readonly shared: boolean }) => {
+    for (let x = 0; x < side; x++) {
+        for (let y = 0; y < side; y++) {
+            const spawn = commands.spawn([cell, value], { [cell]: [x, y] });
+            for (let k = 0; k < perCell; k++) {
+                if (input.shared) spawn({ [value]: k });
+                else commands.spawn([group, value])({ [group]: x * side + y, [value]: k });
+            }
+        }
+    }
+});
+const touchAll = System.create({ kernel: false, components: { with: [value] } }, row => {
+    row[value] += 1;
+});
+
+const small = async (shared: boolean): Promise<number> => {
+    const world = createWorld({ [workers]: 0 });
+    await world.run(seedSmall, { shared });
+    const best = await fastest(() => world.run(touchAll));
+    await world.dispose();
+    return best;
+};
+
+const readsPer = { per: "rows", n: rows, typical: [1_000, 100_000], best: { bytes: 16, basis: "Each row reads its 8-byte lift, its archetype's for a shared one, and reads and writes its 8-byte height." } } as const;
+
+export const sharedBenchmarks: readonly Benchmark[] = [
+    {
+        name: "shared read 100K",
+        operation: "A main-thread row system adding its archetype's value of a shared component to a column, over 100K rows: the baseline is `column read 100K`.",
+        ...readsPer,
+        run: () => reads(raiseShared),
+    },
+    {
+        name: "column read 100K",
+        operation: "As `shared read 100K`, reading a column of each row's own value instead.",
+        ...readsPer,
+        run: () => reads(raiseColumn),
+    },
+    {
+        name: "shared read 100K kernel",
+        operation: "As `shared read 100K`, compiled to a kernel, which takes the value as a parameter of each call.",
+        ...readsPer,
+        run: () => reads(raiseSharedKernel),
+    },
+    {
+        name: "column read 100K kernel",
+        operation: "As `column read 100K`, compiled to a kernel.",
+        ...readsPer,
+        run: () => reads(raiseColumnKernel),
+    },
+    {
+        name: "spawn singles shared",
+        operation: "A run spawning one entity into each of four cells, by a spawner with a shared constant each: the fixed cost of a few spawns into chunks; `spawn singles plain` spawns into four archetypes of columns.",
+        per: "spawns",
+        n: 4,
+        typical: [1, 10],
+        best: { bytes: 64 / 4 + 24, basis: "Each entity writes its values, entity and location, and the run reads a cache line of its system's state." },
+        run: () => spawns(spawnPreset, false),
+    },
+    {
+        name: "spawn singles plain",
+        operation: "As `spawn singles shared`, into four archetypes of columns, by spawners without constants.",
+        per: "spawns",
+        n: 4,
+        typical: [1, 10],
+        best: { bytes: 64 / 4 + 24, basis: "Each entity writes its values, entity and location, and the run reads a cache line of its system's state." },
+        run: () => spawns(spawnPlain, false),
+    },
+    {
+        name: "spawn bulk shared",
+        operation: "A system spawning 100K entities into one cell, by one spawner with a shared constant, and their sync point: populating a chunk.",
+        per: "spawns",
+        n: rows,
+        typical: [100, 100_000],
+        best: { bytes: 24, basis: "Each entity writes its 8-byte value, its 8-byte entity and its 8-byte location." },
+        run: () => spawns(spawnBulkPreset, true),
+    },
+    {
+        name: "spawn bulk plain",
+        operation: "As `spawn bulk shared`, the cell a column of each entity's own.",
+        per: "spawns",
+        n: rows,
+        typical: [100, 100_000],
+        best: { bytes: 32, basis: "Each entity writes its two 8-byte values, its 8-byte entity and its 8-byte location." },
+        run: () => spawns(spawnBulkPlain, true),
+    },
+    {
+        name: "where 1K cells still",
+        operation: "A system with `where` over 1K cells of ten rows, visiting the 3 × 3 cells in a camera's view, the camera still: what culling costs a run once evaluated.",
+        per: "cells",
+        n: side * side,
+        typical: [100, 10_000],
+        best: { bytes: 64 / (side * side) + 9 * perCell * 16 / (side * side), basis: "The run reads a cache line of its state, and each visited row reads and writes its 8-byte value." },
+        run: () => culling(still),
+    },
+    {
+        name: "where 1K cells moving",
+        operation: "As `where 1K cells still`, the camera moving a cell each run: every cell's predicate is evaluated again.",
+        per: "cells",
+        n: side * side,
+        typical: [100, 10_000],
+        best: { bytes: 8 + 9 * perCell * 16 / (side * side), basis: "Each cell's value is read once, and each visited row reads and writes its 8-byte value." },
+        run: () => culling(moving),
+    },
+    {
+        name: "where changed 1K cells drifting",
+        operation: "A system with `where` and `changed` over the 3 × 3 cells of 1K in a camera's view, each run after 1% of their 10K rows moved to the next cell with a new value: a culled system following what moves into its view.",
+        per: "cells",
+        n: side * side,
+        typical: [100, 10_000],
+        best: { bytes: 64 / (side * side), basis: "The run reads a cache line of its state; the rows moving into view are a few of the run's." },
+        run: () => drifting(seeChanged, 1),
+    },
+    {
+        name: "where changed 1K cells drifting in view",
+        operation: "As `where changed 1K cells drifting`, every cell in the camera's view: each run's moves arrive in cells it goes over.",
+        per: "cells",
+        n: side * side,
+        typical: [100, 10_000],
+        best: { bytes: movers * 8 / (side * side), basis: "Each changed row's 8-byte value is read." },
+        run: () => drifting(seeChanged, side),
+    },
+    {
+        name: "changed 1K cells drifting",
+        operation: "As `where changed 1K cells drifting`, the system without `where`, over every cell's changed rows.",
+        per: "cells",
+        n: side * side,
+        typical: [100, 10_000],
+        best: { bytes: movers * 8 / (side * side), basis: "Each changed row's 8-byte value is read." },
+        run: () => drifting(seeChangedEverywhere, 1),
+    },
+    {
+        name: "one row after 100K cells walked",
+        operation: "A main-thread row system over one row, after the entity walked through 100K cells, one a run, each cell's archetype emptied behind it: what a world that has seen many values costs a run; `one row before a walk` is the same before it.",
+        per: "runs",
+        n: 1,
+        typical: [1, 1],
+        best: { bytes: 64, basis: "A run reads at least one cache line of its system's state." },
+        run: () => walking(100_000),
+    },
+    {
+        name: "one row before a walk",
+        operation: "As `one row after 100K cells walked`, before the walk.",
+        per: "runs",
+        n: 1,
+        typical: [1, 1],
+        best: { bytes: 64, basis: "A run reads at least one cache line of its system's state." },
+        run: () => walking(0),
+    },
+    {
+        name: "walk to a new cell",
+        operation: "A run moving one entity to a cell it never visited, and its sync point: an archetype for the new value, reused from those reclaimed behind it, and the one it left emptied.",
+        per: "runs",
+        n: 1,
+        typical: [1, 1],
+        best: { bytes: 64, basis: "A run reads at least one cache line of its system's state." },
+        run: () => walkingOn(),
+    },
+    {
+        name: "flicker between 2 cells",
+        operation: "A run moving one entity to the other of two cells, and its sync point: an archetype emptied and filled again each sync point, which reclaiming waits out.",
+        per: "runs",
+        n: 1,
+        typical: [1, 1],
+        best: { bytes: 64, basis: "A run reads at least one cache line of its system's state." },
+        run: () => flickering(2),
+    },
+    {
+        name: "circle 8 cells",
+        operation: "As `flicker between 2 cells`, round 8 cells, each emptied for 7 sync points, past what reclaiming waits: each run's cell's archetype reclaimed and reused.",
+        per: "runs",
+        n: 1,
+        typical: [1, 1],
+        best: { bytes: 64, basis: "A run reads at least one cache line of its system's state." },
+        run: () => flickering(8),
+    },
+    {
+        name: "small archetypes 1K",
+        operation: "A main-thread row system over 10K rows in 1K archetypes of one shared value each: the cost of many small archetypes; `one archetype 10K` holds the same rows with a column.",
+        per: "rows",
+        n: side * side * perCell,
+        typical: [1_000, 100_000],
+        best: { bytes: 16, basis: "Each row reads and writes its 8-byte value." },
+        run: () => small(true),
+    },
+    {
+        name: "one archetype 10K",
+        operation: "As `small archetypes 1K`, the rows in one archetype, each with its group's number in a column.",
+        per: "rows",
+        n: side * side * perCell,
+        typical: [1_000, 100_000],
+        best: { bytes: 16, basis: "Each row reads and writes its 8-byte value." },
+        run: () => small(false),
+    },
+];