@adobe/ecs 0.0.0-stage → 0.1.0

package/src/perftest/observed.ts

@@ -0,0 +1,298 @@
+import { Component } from "../interface/component/component.js";
+import type { Entity } from "../interface/entity/entity.js";
+import { Resource } from "../interface/resource/resource.js";
+import { workers } from "../interface/resources/workers.js";
+import { System } from "../interface/system/system.js";
+import type { World } from "../interface/world/world.js";
+import { createWorld } from "../implementation/index.js";
+import { Observe } from "../observe/index.js";
+import type { Benchmark } from "./benchmark.js";
+import { fastest } from "./suite.js";
+
+// Benchmarks of the internal observer factories of `src/observe`.
+
+const level = Symbol("observed/level");
+const value = Symbol("observed/value");
+const rank = Symbol("observed/rank");
+const marked = Symbol("observed/marked");
+const unmatched = Symbol("observed/unmatched");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [value]: { type: number };
+        [rank]: { type: number };
+        [marked]: { type: true };
+        [unmatched]: { type: true };
+    }
+    export interface Resources {
+        [level]: { type: number };
+    }
+}
+Resource.register(level, { type: { type: "number", default: 3 } });
+Component.register(value, { type: { type: "number" } });
+Component.register(rank, { type: { type: "number" } });
+Component.register(marked, { type: { const: true } });
+Component.register(unmatched, { type: { const: true } });
+
+/** `count` entities with a value and a rank, the first of them marked. */
+const seed = System.create({ name: "observed/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+    commands.spawn([value, rank, marked])({ [value]: 0, [rank]: 0, [marked]: true });
+    for (let i = 1; i < input.count; i++) commands.spawn([value, rank])({ [value]: (i * 7919) % input.count, [rank]: i });
+});
+
+/** Writes the marked entity's value, so one entity observer is notified and a selection or count is a candidate. */
+const nudge = System.create({ name: "observed/nudge", components: { has: [marked], write: [value] } }, row => { row[value] += 1; });
+
+/** A kernel writing every row's rank. */
+const advance = System.create({ name: "observed/advance", kernel: "cpu", components: { write: [rank] } }, row => { row[rank] += 1; });
+
+/** A system no entity matches: a run that changes nothing. */
+const idle = System.create({ name: "observed/idle", components: { has: [unmatched] } }, () => {});
+
+const check = (condition: boolean, message: string): void => {
+    if (!condition) throw new Error(message);
+};
+
+/** Resolves once observers subscribed before it had their first values: a run after the factories flush. */
+const settled = async (world: World): Promise<void> => {
+    await Promise.resolve();
+    await world.run(idle);
+};
+
+const seeded = async (count: number): Promise<World> => {
+    const world = createWorld({ [workers]: 0 });
+    await world.run(seed, { count });
+    return world;
+};
+
+/** Every entity a seeded world holds. */
+const entitiesOf = (world: World): Promise<readonly Entity[]> => Observe.toPromise(Observe.select(world, { required: [value] }));
+
+/** As `fastest`: the fastest timed run of `run` within `budget` milliseconds of them, each after an untimed `prepare`. */
+const fastestPrepared = async (prepare: () => Promise<unknown>, run: () => Promise<unknown>, budget = 1000): Promise<number> => {
+    for (let warm = 0; warm < 10; warm++) {
+        await prepare();
+        await run();
+    }
+    let best = Infinity;
+    let spent = 0;
+    while (spent < budget) {
+        await prepare();
+        const start = performance.now();
+        await run();
+        const time = performance.now() - start;
+        spent += time;
+        best = Math.min(best, time);
+    }
+    return best;
+};
+
+type SelectQuery = Parameters<typeof Observe.select<readonly [typeof value, typeof rank]>>[1];
+
+const observedEntities = 1_000;
+const movingEntities = 100_000;
+const selectedRows = 100_000;
+const countedEntities = 1_000_000;
+
+let copied = 0;
+
+/** A world with an entity observer of each of its entities, which had its first value. */
+const observedWorld = async (): Promise<{ readonly world: World; readonly stop: () => void; readonly notified: () => number }> => {
+    const world = await seeded(observedEntities);
+    let notified = 0;
+    const stops = (await entitiesOf(world)).map(entity => Observe.entity(world, entity, { required: [value] })(() => { notified++; }));
+    await settled(world);
+    notified = 0;
+    return { world, stop: () => { for (const stop of stops) stop(); }, notified: () => notified };
+};
+
+/** A page of `select page 100K` and `select page 100K churn`: a sorted, filtered list of a UI. */
+const pageQuery = (offset: number): SelectQuery => ({ required: [value, rank], where: { [rank]: { "<": selectedRows / 2 } }, order: { [value]: false }, page: { offset, limit: 20 } });
+
+export const observedBenchmarks: readonly Benchmark[] = [
+    {
+        name: "read observe factory warm",
+        operation: "Reading a resource through an observer factory's first value, `Observe.toPromise(Observe.resource(world, key))`, while the factories hold its value: a value read from outside the world, again.",
+        per: "reads",
+        n: 1,
+        typical: [1, 100],
+        best: { bytes: 64, basis: "A read loads at least one cache line of the resource's cell." },
+        run: async () => {
+            const world = await seeded(10_000);
+            const best = await fastest(async () => { copied = await Observe.toPromise(Observe.resource(world, level)); });
+            check(copied === 3, "read observe factory warm: wrong value");
+            await world.dispose();
+            return best;
+        },
+    },
+    {
+        name: "read observe factory cold",
+        operation: "Reading a resource through an observer factory's first value while the factories hold nothing of it, their observer system for it removed after idle passes: a run of observer systems for one read.",
+        per: "reads",
+        n: 1,
+        typical: [1, 100],
+        best: { bytes: 64, basis: "A read loads at least one cache line of the resource's cell." },
+        run: async () => {
+            const world = await seeded(10_000);
+            const evict = async (): Promise<void> => {
+                for (let i = 0; i < 3; i++) await world.run(idle);
+            };
+            const best = await fastestPrepared(evict, async () => { copied = await Observe.toPromise(Observe.resource(world, level)); });
+            check(copied === 3, "read observe factory cold: wrong value");
+            await world.dispose();
+            return best;
+        },
+    },
+    {
+        name: "observe 1K entities factory",
+        operation: "A run that changes nothing with an entity observer on each of 1K entities, through the observer factories: what watching entities costs each frame.",
+        per: "observers",
+        n: observedEntities,
+        typical: [10, 1_000],
+        best: { bytes: 16, basis: "Each observer reads its entity's 8-byte location and its component's 8-byte changed tick." },
+        run: async () => {
+            const { world, stop, notified } = await observedWorld();
+            const best = await fastest(() => world.run(idle));
+            check(notified() === 0, "observe 1K entities factory: notified");
+            stop();
+            await world.dispose();
+            return best;
+        },
+    },
+    {
+        name: "observe 1K entities one changed factory",
+        operation: "A run that changes one of 1K entities, each with an entity observer, through the observer factories: what watching entities costs each frame while one of them changes.",
+        per: "observers",
+        n: observedEntities,
+        typical: [10, 1_000],
+        best: { bytes: 16, basis: "Each observer reads its entity's 8-byte location and its component's 8-byte changed tick." },
+        run: async () => {
+            const { world, stop, notified } = await observedWorld();
+            const best = await fastest(() => world.run(nudge));
+            check(notified() > 0, "observe 1K entities one changed factory: not notified");
+            stop();
+            await world.dispose();
+            return best;
+        },
+    },
+    {
+        name: "observe one entity among 100K moving factory",
+        operation: "A kernel writing the rank of 100K entities, one of them observed, through the observer factories: a debugging view of one entity in a moving world, beyond the kernel's own time.",
+        per: "runs",
+        n: 1,
+        typical: [1, 1],
+        best: { bytes: 800_000, basis: "The kernel reads and writes 100K 4-byte ranks; observing one entity adds a cache line." },
+        run: async () => {
+            const world = await seeded(movingEntities);
+            const [first] = await entitiesOf(world);
+            let notified = 0;
+            const stop = Observe.entity(world, first, { required: [rank] })(() => { notified++; });
+            await world.run(advance);
+            const before = notified;
+            const best = await fastest(() => world.run(advance));
+            check(notified > before, "observe one entity among 100K moving factory: not notified");
+            stop();
+            await world.dispose();
+            return best;
+        },
+    },
+    {
+        name: "observe subscribe churn 1K factory",
+        operation: "Subscribing an entity observer to each of 1K entities, a run, and stopping them all, through the observer factories: views opened and closed each frame.",
+        per: "observers",
+        n: observedEntities,
+        typical: [10, 1_000],
+        best: { bytes: 16, basis: "Each observer reads its entity's 8-byte location and its component's 8-byte value." },
+        run: async () => {
+            const world = await seeded(observedEntities);
+            const entities = await entitiesOf(world);
+            let notified = 0;
+            const notify = (): void => { notified++; };
+            const best = await fastest(async () => {
+                const stops = entities.map(entity => Observe.entity(world, entity, { required: [value] })(notify));
+                await world.run(idle);
+                for (const stop of stops) stop();
+            });
+            check(notified > 0, "observe subscribe churn 1K factory: no first values");
+            await world.dispose();
+            return best;
+        },
+    },
+    {
+        name: "select page 100K factory",
+        operation: "A run that changes one entity's order component under an observer factory's `select` with `where`, `order` and a 20-row `page` over 100K entities: a sorted, filtered list of a UI, kept current through a sorted index.",
+        per: "rows",
+        n: selectedRows,
+        typical: [1_000, 100_000],
+        best: { bytes: 16, basis: "Each row reads its 8-byte rank and its 8-byte value." },
+        run: async () => {
+            const world = await seeded(selectedRows);
+            let page: readonly Entity[] = [];
+            const stop = Observe.select(world, pageQuery(100))(selected => { page = selected; });
+            await settled(world);
+            const best = await fastest(() => world.run(nudge));
+            check(page.length === 20, "select page 100K factory: wrong page");
+            stop();
+            await world.dispose();
+            return best;
+        },
+    },
+    {
+        name: "select page 100K churn factory",
+        operation: "The first value of a 20-row page of a `select` with `where` and `order` over 100K entities, at another offset each time, while another observer of that query keeps it current, through the observer factories: a UI paging.",
+        per: "reads",
+        n: 1,
+        typical: [1, 100],
+        best: { bytes: 320, basis: "A page reads 20 entries of 16 bytes: an entity, its rank and its value." },
+        run: async () => {
+            const world = await seeded(selectedRows);
+            const stop = Observe.select(world, pageQuery(0))(() => {});
+            await settled(world);
+            let offset = 0;
+            let page: readonly Entity[] = [];
+            const best = await fastest(async () => {
+                offset = (offset + 20) % 2_000;
+                page = await Observe.toPromise(Observe.select(world, pageQuery(offset)));
+            });
+            check(page.length === 20, "select page 100K churn factory: wrong page");
+            stop();
+            await world.dispose();
+            return best;
+        },
+    },
+    {
+        name: "select factory",
+        operation: "The first value of an observer factory's `select` with `where` over 1M entities, which the factories hold nothing of: one scan, a run of an observer system over the rows that match.",
+        per: "rows",
+        n: 1_000_000,
+        typical: [100, 100_000],
+        best: { bytes: 8, basis: "Each row reads its 4-byte rank; each selected half writes its 8-byte entity." },
+        run: async () => {
+            const world = await seeded(1_000_000);
+            const best = await fastest(async () => {
+                const selected = await Observe.toPromise(Observe.select(world, { required: [value, rank], where: { [rank]: { "<": 500_000 } } }));
+                check(selected.length === 500_000, "select factory: wrong count");
+            });
+            await world.dispose();
+            return best;
+        },
+    },
+    {
+        name: "count 1M changed factory",
+        operation: "A run that changes one entity's value under a `count` with `where` over 1M entities, through the observer factories: a filtered total of a UI, counted again after a change.",
+        per: "rows",
+        n: countedEntities,
+        typical: [1_000, 1_000_000],
+        best: { bytes: 8, basis: "Each row reads its 8-byte value." },
+        run: async () => {
+            const world = await seeded(countedEntities);
+            let counted = 0;
+            const stop = Observe.count(world, { required: [value], where: { [value]: { "<": countedEntities / 2 } } })(next => { counted = next; });
+            await settled(world);
+            const best = await fastest(() => world.run(nudge));
+            check(counted > 0, "count 1M changed factory: nothing counted");
+            stop();
+            await world.dispose();
+            return best;
+        },
+    },
+];

package/src/perftest/observer.ts

@@ -0,0 +1,57 @@
+import type { Component } from "../interface/component/component.js";
+import type { Entity } from "../interface/entity/entity.js";
+import { clock } from "../interface/resources/clock.js";
+import { System } from "../interface/system/system.js";
+import type { World } from "../interface/world/world.js";
+
+// Benchmarks read a world as consumers do, through observer systems: a run of one made for a read leaves nothing added
+// to the world, so the runs timed after it run what they ran before.
+
+/**
+ * Calls `notify` after each tick, and once after the first pass it runs in, from an observer system it adds to `world`
+ * filtering on the clock, until the function it returns removes it: how benchmarks count ticks back to back, where that
+ * first call only starts the stretch that warms up.
+ */
+export const eachTick = (world: World, notify: () => void): (() => void) => {
+    const counter = System.create({ name: "perftest/eachTick", observer: true, resources: { changed: [clock] } }, () => { notify(); });
+    world.add(counter);
+    return () => world.remove(counter);
+};
+
+/** The clock as an observer run last read it. */
+const read = { tick: 0, now: 0 };
+const readClock = System.create({ name: "perftest/readClock", observer: true, resources: { read: [clock] } }, ({ resources }) => {
+    read.tick = resources[clock].tick;
+    read.now = resources[clock].now;
+});
+
+/**
+ * Resolves once `count` ticks ran after the clock an observer run reads now, which doesn't wake the loop. A tick is
+ * told from the clock before it by its count and its `now` together: the first tick's count is 0, as before it, and
+ * back-to-back ticks can share a `now` at a coarse timer.
+ */
+export const ticksAfter = async (world: World, count: number): Promise<void> => {
+    await world.run(readClock);
+    let { tick, now } = read;
+    let seen = 0;
+    await new Promise<void>(resolve => {
+        const counter = System.create({ name: "perftest/ticksAfter", observer: true, resources: { read: [clock] } }, ({ resources }) => {
+            const current = resources[clock];
+            if (current.tick === tick && current.now === now) return;
+            tick = current.tick;
+            now = current.now;
+            if (++seen < count) return;
+            queueMicrotask(() => world.remove(counter));
+            resolve();
+        });
+        world.add(counter);
+    });
+};
+
+/** The entities with every component of `has` and none of `not`, in storage order, read by an observer run. */
+export const entitiesWith = async (world: World, has: readonly Component.Key[], not: readonly Component.Key[] = []): Promise<Entity[]> => {
+    const found: Entity[] = [];
+    await world.run(System.create({ observer: true, components: { has, not } }, row => { found.push(row.entity); }));
+    return found;
+};
+

package/src/perftest/particles.ts

@@ -0,0 +1,76 @@
+import { Archetype } from "../interface/archetype/archetype.js";
+import { Component } from "../interface/component/component.js";
+import type { Schema } from "../interface/schema/schema.js";
+import { System } from "../interface/system/system.js";
+
+// Mirrors adobe/data's ecs1/ecs2 perftests (packages/data/src/perftest): 1M particles split evenly across
+// 4 archetypes by visible/enabled; move adds velocity to position for the visible and enabled quarter.
+
+type Vec3 = readonly [number, number, number];
+const vec3 = { type: "array", items: { type: "number", precision: 1 }, minItems: 3, maxItems: 3 } as const satisfies Schema;
+
+const color = Symbol("perf/color");
+const mass = Symbol("perf/mass");
+export const position = Symbol("perf/position");
+const velocity = Symbol("perf/velocity");
+export const visible = Symbol("perf/visible");
+export const enabled = Symbol("perf/enabled");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [color]: { type: number };
+        [mass]: { type: number };
+        [position]: { type: readonly [number, number, number] };
+        [velocity]: { type: readonly [number, number, number] };
+        [visible]: { type: true };
+        [enabled]: { type: true };
+    }
+}
+
+Component.register(color, { type: { type: "integer", minimum: 0, maximum: 0xFFFFFFFF } });
+Component.register(mass, { type: { type: "number", precision: 1 } });
+Component.register(position, { type: vec3 });
+Component.register(velocity, { type: vec3 });
+Component.register(visible, { type: { const: true } });
+Component.register(enabled, { type: { const: true } });
+
+/** Interleaved like ecs2's seedSingle: entity i goes to archetype i % 4. */
+const archetypes = [
+    Archetype.create([color, mass, position, velocity, visible, enabled]),
+    Archetype.create([color, mass, position, velocity, visible]),
+    Archetype.create([color, mass, position, velocity, enabled]),
+    Archetype.create([color, mass, position, velocity]),
+] as const;
+
+export const spawn = System.create({ name: "perf/spawn", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+    for (let i = 0; i < input.count; i++) {
+        const p = [i + 1, i + 1, i + 1] as const;
+        const v = [-i, -i, -i] as const;
+        commands.spawn(archetypes[i % 4])({ [color]: 0xff00ff, [mass]: 10, [position]: p, [velocity]: v });
+    }
+});
+
+export const move = System.create({
+    name: "perf/move",
+    kernel: "cpu",
+    components: { read: [velocity], write: [position], has: [visible, enabled] },
+}, row => {
+    const [px, py, pz] = row[position];
+    const [vx, vy, vz] = row[velocity];
+    row[position] = [px + vx, py + vy, pz + vz];
+});
+
+/** Fastest of repeated runs within a time budget, like the adobe/data harness. */
+export const fastest = async (run: () => Promise<unknown>, budget = 1000): Promise<{ readonly minimum: number; readonly passes: number }> => {
+    for (let warm = 0; warm < 20; warm++) await run();
+    let minimum = Infinity;
+    let passes = 0;
+    const end = performance.now() + budget;
+    while (performance.now() < end) {
+        const start = performance.now();
+        await run();
+        minimum = Math.min(minimum, performance.now() - start);
+        passes++;
+    }
+    return { minimum, passes };
+};

package/src/perftest/placed.ts

@@ -0,0 +1,177 @@
+import type { World } from "../interface/world/world.js";
+import { workers } from "../interface/resources/workers.js";
+import { createWorld } from "../implementation/world/create.js";
+import type { Benchmark, Best } from "./benchmark.js";
+import { forest, propagate } from "./hierarchy.js";
+import { fastest as particlesFastest, move, spawn } from "./particles.js";
+import { chain, emit, fastest, follow, hits, observe, poke, seeded } from "./suite.js";
+import * as structural from "./structural.js";
+import { bumpEach, fillEach, spawnEach } from "./growth.js";
+// Last, so the modules the benchmarks share load in the order they did before it.
+import { Observe } from "../observe/index.js";
+
+/** Benchmarks run on the world's thread alone and on the pool, in chromium and, for some, in node. */
+
+/** Doublings `sync point grow 100 archetypes` times, from archetypes of 16 rows, in each of `rounds` worlds. */
+const doublings = 6;
+const rounds = 8;
+
+/** Every hardware thread but the world's. */
+export const threads = navigator.hardwareConcurrency - 1;
+
+export type Placement = { readonly label: string; readonly workers: number; readonly on?: Best["on"] };
+export const main: Placement = { label: "main", workers: 0 };
+export const pooled: Placement = { label: "workers", workers: threads, on: "threads" };
+
+/** A world of the placement, measured, then disposed. */
+const measured = async (placement: Placement, run: (world: World) => Promise<number>): Promise<number> => {
+    const world = createWorld({ [workers]: placement.workers });
+    try {
+        return await run(world);
+    } finally {
+        await world.dispose();
+    }
+};
+
+export const upOperation = (chains: string): string => `A kernel with \`up\` computing every row from its parent, over ${chains}: transforms, inherited visibility or style, recomputed in full.`;
+export const upBest = { bytes: 28, basis: "Each row reads its 8-byte value, its parent's 8-byte result and 4-byte row, and writes its 8-byte result." };
+
+/** The benchmarks of each placement. */
+export const placed = (placements: readonly Placement[]): readonly Benchmark[] => [
+    ...placements.flatMap((placement): readonly Benchmark[] => [
+        {
+            name: `move ${placement.label}`,
+            operation: "A kernel adding a vec3 to another for the rows with two tags: integration, animation, any per-row update.",
+            per: "matched rows",
+            n: 250_000,
+            typical: [1_000, 1_000_000],
+            best: { bytes: 36, basis: "Each row reads 12 bytes of velocity and reads and writes 12 bytes of position.", on: placement.on },
+            run: () => measured(placement, async world => {
+                await world.run(spawn, { count: 1_000_000 });
+                return (await particlesFastest(() => world.run(move))).minimum;
+            }),
+        },
+        {
+            name: `follow ${placement.label}`,
+            operation: "A kernel looking up another entity per row and reading its position: steering toward targets, constraints, attachments.",
+            per: "rows",
+            n: 1_000_000,
+            typical: [1_000, 100_000],
+            best: { bytes: 52, basis: "Each row reads 12 bytes of position and an 8-byte target, the target's 8-byte location and 12-byte position, and writes 12.", on: placement.on },
+            run: () => measured(placement, async world => {
+                await seeded(() => world, 1_000_000);
+                return fastest(() => world.run(follow));
+            }),
+        },
+        {
+            name: `chain ${placement.label}`,
+            operation: "Six dependent kernels over the same rows, each reading what the one before wrote: a pipeline of per-row steps.",
+            per: "row passes",
+            n: 6_000_000,
+            typical: [6_000, 6_000_000],
+            best: { bytes: 4, basis: "Fused into one pass, each row reads and writes its 12-byte velocity once for all six.", on: placement.on },
+            run: () => measured(placement, async world => {
+                await seeded(() => world, 1_000_000);
+                return fastest(() => world.run(chain));
+            }),
+        },
+        {
+            name: `sparse changed ${placement.label}`,
+            operation: "A kernel filtered on `changed` after 1% of rows changed, scattered: reacting to edits, such as recomputing bounds of what moved.",
+            per: "rows in the archetype",
+            n: 1_000_000,
+            typical: [10_000, 1_000_000],
+            best: { bytes: 8.24, basis: "Every chunk has a change, so each row's 8-byte tick is read; the changed 1% read 12 bytes and write 12.", on: placement.on },
+            run: () => measured(placement, async world => {
+                await seeded(() => world, 1_000_000);
+                let frame = 0;
+                let best = Infinity;
+                for (let i = 0; i < 200; i++) {
+                    await world.run(poke, { group: frame++ % 100 });
+                    const start = performance.now();
+                    await world.run(observe);
+                    if (i >= 20) best = Math.min(best, performance.now() - start);
+                }
+                return best;
+            }),
+        },
+        {
+            name: `emit ${placement.label}`,
+            operation: "A kernel issuing an add for a tenth of its rows: hits, events or state changes found by a parallel pass.",
+            per: "rows",
+            n: 1_000_000,
+            typical: [1_000, 100_000],
+            best: { bytes: 34, basis: "Each row reads 16 bytes; each tenth moves to a new archetype, about 180 bytes.", on: placement.on },
+            run: () => measured(placement, async world => {
+                await seeded(() => world, 1_000_000);
+                const best = await fastest(() => world.run(emit));
+                if (await Observe.toPromise(Observe.count(world, { required: [hits] })) !== 100_000) throw new Error(`emit ${placement.label}: wrong count`);
+                return best;
+            }),
+        },
+        {
+            name: `spawn bulk kernel ${placement.label}`,
+            operation: "A kernel spawning an entity per row over 100K rows: spawns found by a parallel pass, such as debris or hits.",
+            per: "spawns",
+            n: 100_000,
+            typical: [100, 100_000],
+            best: { bytes: 28, basis: "Each row reads its 4-byte index; each spawn writes its 8 bytes of values, its entity and its location.", on: placement.on },
+            run: () => measured(placement, async world => {
+                await world.run(structural.seed, { count: 100_000, sources: 1 });
+                let best = Infinity;
+                for (let i = 0; i < 40; i++) {
+                    await world.run(structural.despawnSpawned);
+                    const start = performance.now();
+                    await world.run(structural.spawnKernel);
+                    if (i >= 8) best = Math.min(best, performance.now() - start);
+                }
+                return best;
+            }),
+        },
+        ...[[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} ${placement.label}`,
+            operation: upOperation(String(chains)),
+            per: "rows",
+            n: 1_000_000,
+            typical: [1_000, 100_000],
+            best: { ...upBest, on: placement.on },
+            run: () => measured(placement, async world => {
+                await world.run(forest, { roots: Number(roots), depth: Number(depth) });
+                return fastest(() => world.run(propagate));
+            }),
+        })),
+    ]),
+    ...placements.map((placement): Benchmark => ({
+        name: `sync point grow 100 archetypes ${placement.label}`,
+        operation: placement.workers === 0
+            ? "A sync point where each of 100 archetypes grows, by one spawn into each: levels and bursts filling many kinds of entities at once."
+            : "A sync point where each of 100 archetypes grows, by one spawn into each, then a kernel over them, so workers take up the new layout.",
+        per: "archetypes grown",
+        n: 100,
+        typical: [1, 100],
+        best: { bytes: 64, basis: "Each archetype that grows writes at least its layout record, a cache line.", on: placement.on },
+        run: async () => {
+            let best = Infinity;
+            for (let round = 0; round < rounds; round++) {
+                const world = createWorld({ [workers]: placement.workers }, { minimumChunk: 16 });
+                try {
+                    // Registers both systems and loads the kernel; then every archetype holds one row of its 16.
+                    await world.run(spawnEach);
+                    await world.run(bumpEach);
+                    let count = 1;
+                    for (let capacity = 16, d = 0; d < doublings; d++, capacity *= 2) {
+                        await world.run(fillEach, { count: capacity - count });
+                        const start = performance.now();
+                        await world.run(spawnEach);
+                        if (placement.workers > 0) await world.run(bumpEach);
+                        best = Math.min(best, performance.now() - start);
+                        count = capacity + 1;
+                    }
+                } finally {
+                    await world.dispose();
+                }
+            }
+            return best;
+        },
+    })),
+];