@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/layout-directory.fixture.ts

@@ -1,4 +1,4 @@
-import { Component } from "../../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Entity } from "../../interface/entity/entity.js";
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
@@ -6,6 +6,7 @@ import { workers } from "../../interface/resources/workers.js";
 import { readEach, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
 import { countingWorkers } from "./platforms.test-helper.js";
+import type { F32 } from "../../interface/math/index.js";
 
 /** Scenarios of workers reading layouts from the directory, run built in node and from source in chromium. */
 
@@ -24,9 +25,9 @@ const tags = [tag0, tag1, tag2, tag3, tag4, tag5, tag6] as const;
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [value]: { type: number };
+        [value]: { type: F32 };
         [target]: { type: Entity };
-        [seen]: { type: number };
+        [seen]: { type: F32 };
         [child]: { type: true };
         [tag0]: { type: true };
         [tag1]: { type: true };
@@ -38,66 +39,54 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(value, { type: { type: "number", precision: 1 } });
-Component.register(target, { type: Entity.schema });
-Component.register(seen, { type: { type: "number", precision: 1 } });
-Component.register(child, { type: { const: true } });
-Component.register(tag0, { type: { const: true } });
-Component.register(tag1, { type: { const: true } });
-Component.register(tag2, { type: { const: true } });
-Component.register(tag3, { type: { const: true } });
-Component.register(tag4, { type: { const: true } });
-Component.register(tag5, { type: { const: true } });
-Component.register(tag6, { type: { const: true } });
 
 /** The component lists of 100 archetypes: `value` with each of the first 100 combinations of the tags. */
 const lists = Array.from({ length: 100 }, (_, i): (typeof value | (typeof tags)[number])[] => [value, ...tags.filter((_, bit) => (i & (1 << bit)) !== 0)]);
 
 /** Spawns `count` entities into each of the 100 archetypes. */
-const fill = System.create({ name: "layoutDirectoryTest/fill", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+const fill = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (const list of lists) for (let i = 0; i < input.count; i++) commands.spawn(list)({ [value]: 0 });
 });
 
-const bump = System.create({ name: "layoutDirectoryTest/bump", kernel: "cpu", components: { write: [value] } }, row => {
+const bump = System.create({ kernel: true, components: { with: [value] } }, row => {
     row[value] = row[value] + 1;
 });
 
 const total = { sum: 0, count: 0 };
 /** Sums every value on the world's thread, so it reads what workers wrote. */
-const sum = System.create({ name: "layoutDirectoryTest/sum", components: { read: [value] } }, row => {
+const sum = System.create({ components: { with: [value] } }, row => {
     total.sum += row[value];
     total.count++;
 });
 
 /** Entities whose values the lookups read, recorded as they spawn. */
 const spawned: Entity[] = [];
-const make = System.create({ name: "layoutDirectoryTest/make" }, ({ commands }) => {
+const make = System.create({}, ({ commands }) => {
     for (let i = 0; i < 64; i++) commands.spawn([target, seen])({ [target]: Entity.none, [seen]: 0 });
     commands.spawn([value])({ [value]: -1 });
 });
-const spawnMany = System.create({ name: "layoutDirectoryTest/spawnMany", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+const spawnMany = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) spawned.push(commands.spawn([value])({ [value]: i }));
 });
 /** Aims each looker at one of the last spawned entities. */
 let aimed = 0;
-const aim = System.create({ name: "layoutDirectoryTest/aim", components: { write: [target] } }, row => {
+const aim = System.create({ components: { with: [target] } }, row => {
     row[target] = spawned[spawned.length - 1 - aimed++];
 });
-const despawnValues = System.create({ name: "layoutDirectoryTest/despawnValues", components: { has: [value], not: [child] } }, (row, { commands }) => {
+const despawnValues = System.create({ components: { with: [value], not: [child] } }, (row, { commands }) => {
     commands.despawn(row.entity);
 });
 /** Lookups from workers. */
 const look = System.create({
-    name: "layoutDirectoryTest/look",
-    kernel: "cpu",
-    components: { read: [target], write: [seen] },
-    lookup: { targets: { read: [value] } },
+    kernel: true,
+    components: { with: [target, seen] },
+    lookup: { targets: { with: [value] } },
 }, (row, { lookup: { targets } }) => {
     const other = targets(row[target]);
     row[seen] = other === null ? -1 : other[value];
 });
 /** Spawns from workers: a child per looker. */
-const breed = System.create({ name: "layoutDirectoryTest/breed", kernel: "cpu", components: { read: [seen] } }, (row, { commands }) => {
+const breed = System.create({ kernel: true, components: { with: [seen] } }, (row, { commands }) => {
     commands.spawn([value, child])({ [value]: row[seen] });
 });
 
@@ -123,7 +112,8 @@ export const rounds: readonly number[] = [16, 32, 64, 128, 256];
 /** 100 archetypes grown over `rounds`, each round bumped by workers: layout messages after the first round, and the totals. */
 export const grown = async (wasm: boolean): Promise<{ readonly messages: number; readonly totals: { sum: number; count: number } }> => {
     const counting = countingWorkers();
-    return using(createWorld({ [workers]: 3 }, { minimumChunk: 16, wasm, pool: counting.platform }), async world => {
+    // Pieces of two rows, so the first round's single rows start the pool and its layout message is before the count.
+    return using(createWorld({ [workers]: 3 }, { minimumChunk: 2, wasm, pool: counting.platform }), async world => {
         await world.run(fill, { count: 1 });
         await world.run(bump);
         const before = counting.posted("layout");
@@ -164,7 +154,7 @@ export const tableGrown = async (): Promise<{ readonly messages: number; readonl
 /** Workers' kernels once memory grows between runs: how often it grew, layout messages meanwhile, and the totals. */
 export const memoryGrown = async (wasm: boolean): Promise<{ readonly grows: number; readonly messages: number; readonly totals: { sum: number; count: number } }> => {
     const counting = countingWorkers();
-    return using(createWorld({ [workers]: 2 }, { minimumChunk: 16, wasm, pool: counting.platform }), async world => {
+    return using(createWorld({ [workers]: 2 }, { minimumChunk: 2, wasm, pool: counting.platform }), async world => {
         await world.run(fill, { count: 1 });
         await world.run(bump);
         let grows = 0;

package/src/implementation/world/layout-directory.ts

@@ -1,4 +1,5 @@
-import { allocateArray, growArray } from './arrays.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { allocateArray, freeArray, growArray } from './arrays.js';
 import type { Archetype } from './archetype.js';
 import type { Entities } from './entities.js';
 import type { Memory } from './memory.js';
@@ -11,8 +12,9 @@ import type { Memory } from './memory.js';
  *
  * Header words: the memory's length in pages (`memory.ts`), the table's offset and length, the structure epoch, then
  * the entity-table record: its `cursor` offset, which never moves, `free` offset and capacity, `archetype`, `row` and
- * `generation` offsets and their capacity, and its version; then the resource entity's index plus one, 0 for none. The
- * table's length is `cursor[2]`.
+ * `generation` offsets and their capacity, and its version; then the resource entity's index plus one, 0 for none; the
+ * structure epoch's waiters; how many flushes replaced an existing archetype's arrays; and the offset of the ring of
+ * rows' moves (`arrivals.ts`), 0 before one. The table's length is `cursor[2]`.
  *
  * The structure epoch is odd from the start of each sync point that applies anything until its directory writes at the
  * end, and even otherwise. A thread reading entity locations outside a task reads while it's even and checks it again
@@ -34,12 +36,18 @@ export const entitiesVersionField = 7;
 export const resourceEntityWord = 12;
 /** Readers waiting on the structure epoch, so the world notifies only when one is. */
 export const structureWaitersWord = 13;
+/**
+ * Flushes that wrote an existing archetype's record again, its arrays replaced, so a joined thread checks this word
+ * once a run rather than each record's version for every row it reads.
+ */
+export const replacedWord = 14;
 
 /**
- * An archetype record: its capacity, `entities` offset, storage count, version, flags and row count, then per storage
- * its component number, flags, column, `added`, `changed`, `chunkAdded` and `chunkChanged` offsets, and chunk count.
- * Offsets a storage doesn't have are 0. A record is allocated once, since an archetype's storages are fixed, and never
- * moves. Its count is written at flushes while a joined thread may read it, for archetypes whose count changed.
+ * An archetype record: its capacity, `entities` offset, storage count, version, flags, row count and generation, then
+ * per storage its component number, flags, column, `added`, `changed`, `chunkAdded` and `chunkChanged` offsets, chunk count, and
+ * `blockAdded` and `blockChanged` offsets, of `chunks << (chunkShift - blockShift)` blocks. Offsets a storage doesn't
+ * have are 0. A record is allocated once, since an archetype's storages are fixed, and never moves. Its count is
+ * written at flushes while a joined thread may read it, for archetypes whose count changed.
  */
 export const recordCapacity = 0;
 export const recordEntities = 1;
@@ -47,12 +55,13 @@ export const recordStorages = 2;
 export const recordVersion = 3;
 export const recordFlags = 4;
 export const recordCount = 5;
-export const recordWords = 6;
-/** Record flags: it's the resource archetype, of the entity resources live on. */
+/** How many times it was reused for other shared values (`reclaim.ts`), which a joined thread's `where` checks. */
+export const recordGeneration = 6;
+export const recordWords = 7;
+/** Record flags: it's the resource archetype, of the entity resources live on; it's reclaimed, matching no system. */
 export const resourceFlag = 1;
-/** Record flags: it holds reports, which only queries that require a component see. */
-export const metaFlag = 2;
-export const storageWords = 8;
+export const reclaimedFlag = 2;
+export const storageWords = 10;
 export const storageComponent = 0;
 export const storageFlags = 1;
 export const storageColumn = 2;
@@ -61,13 +70,17 @@ export const storageChanged = 4;
 export const storageChunkAdded = 5;
 export const storageChunkChanged = 6;
 export const storageChunks = 7;
+export const storageBlockAdded = 8;
+export const storageBlockChanged = 9;
 /**
  * Storage flags: it keeps ticks; it has a column in linear memory, a string's of handles included; its objects are a joined thread's, whose number is
- * the flags from `threadShift` on, and its column holds each row's tag (`move-log.ts`).
+ * the flags from `threadShift` on, and its column holds each row's tag (`move-log.ts`); it's a shared component's,
+ * whose column is its archetype's value: a word of its length in UTF-16 code units, then its canonical text's.
  */
 export const tickedFlag = 1;
 export const linearFlag = 2;
 export const remoteFlag = 4;
+export const sharedFlag = 8;
 export const threadShift = 8;
 
 /** The world's side of the directory. */
@@ -79,6 +92,8 @@ export type LayoutDirectory = {
     table: Uint32Array;
     /** By archetype id, its record, once flushed. */
     readonly records: (Uint32Array | undefined)[];
+    /** By archetype id, by its storages, the offset of each shared value's text, written with its record, which never moves. */
+    readonly texts: (readonly number[] | undefined)[];
     /** The entity table's version as last flushed. */
     entities: number;
     /** Whether a joined thread may read entity locations outside a task, so sync points keep the structure epoch. */
@@ -94,7 +109,7 @@ export const createLayoutDirectory = (memory: Memory): LayoutDirectory | null =>
     const { header } = memory;
     header[tableOffsetWord] = table.byteOffset;
     header[tableLengthWord] = 0;
-    return { memory, header, words: new Int32Array(header.buffer, header.byteOffset, header.length), table, records: [], entities: -1, guarded: false };
+    return { memory, header, words: new Int32Array(header.buffer, header.byteOffset, header.length), table, records: [], texts: [], entities: -1, guarded: false };
 };
 
 const writeEntities = ({ header }: LayoutDirectory, entities: Entities): void => {
@@ -125,13 +140,44 @@ const recordOf = (directory: LayoutDirectory, archetype: Archetype): Uint32Array
     return record;
 };
 
+/** Each shared value's text an archetype holds, in the memory once, by its storages: 0 for a storage of another component. */
+const textsOf = (directory: LayoutDirectory, archetype: Archetype): readonly number[] => {
+    const known = directory.texts[archetype.id];
+    if (known !== undefined) return known;
+    const offsets = archetype.storages.map(storage => {
+        const text = archetype.texts[storage.component];
+        if (text === undefined) return 0;
+        const words = allocateArray(directory.memory, Uint32Array, 1 + Math.ceil(text.length / 2));
+        words[0] = text.length;
+        const units = new Uint16Array(words.buffer, words.byteOffset + 4, text.length);
+        for (let i = 0; i < text.length; i++) units[i] = text.charCodeAt(i);
+        return words.byteOffset;
+    });
+    directory.texts[archetype.id] = offsets;
+    return offsets;
+};
+
+/** Lets go of the texts of an archetype's shared values, as it's reused for others: its next record writes theirs. */
+export const forgetTexts = (directory: LayoutDirectory, archetype: Archetype): void => {
+    const known = directory.texts[archetype.id];
+    if (known === undefined) return;
+    directory.texts[archetype.id] = undefined;
+    for (const offset of known) {
+        if (offset === 0) continue;
+        const words = new Uint32Array(directory.memory.memory.buffer, offset, 1);
+        freeArray(directory.memory, { byteOffset: offset, byteLength: 4 * (1 + Math.ceil(words[0] / 2)) });
+    }
+};
+
 const writeArchetype = (directory: LayoutDirectory, archetype: Archetype): void => {
     const fresh = directory.records[archetype.id] === undefined;
     const record = recordOf(directory, archetype);
+    const texts = archetype.texts.length === 0 ? null : textsOf(directory, archetype);
     record[recordCapacity] = archetype.capacity;
     record[recordEntities] = archetype.entities.byteOffset;
     record[recordStorages] = archetype.storages.length;
-    record[recordFlags] = (archetype.resource ? resourceFlag : 0) | (archetype.meta ? metaFlag : 0);
+    record[recordFlags] = (archetype.resource ? resourceFlag : 0) | (archetype.reclaimed ? reclaimedFlag : 0);
+    record[recordGeneration] = archetype.generation;
     record[recordCount] = archetype.count;
     for (let s = 0; s < archetype.storages.length; s++) {
         const storage = archetype.storages[s];
@@ -140,13 +186,16 @@ const writeArchetype = (directory: LayoutDirectory, archetype: Archetype): void
         const linear = storage.layout.kind === "linear" || storage.layout.kind === "string";
         const { remote } = storage;
         record[base + storageComponent] = storage.component;
-        record[base + storageFlags] = (storage.ticked ? tickedFlag : 0) | (linear ? linearFlag : 0) | (remote === null ? 0 : remoteFlag | (remote.thread << threadShift));
-        record[base + storageColumn] = linear ? storage.views.u8.byteOffset : remote === null ? 0 : storage.tags.byteOffset;
+        const text = texts === null ? 0 : texts[s];
+        record[base + storageFlags] = (storage.ticked ? tickedFlag : 0) | (linear ? linearFlag : 0) | (remote === null ? 0 : remoteFlag | (remote.thread << threadShift)) | (text === 0 ? 0 : sharedFlag);
+        record[base + storageColumn] = linear ? storage.views.u8.byteOffset : remote === null ? text : storage.tags.byteOffset;
         record[base + storageAdded] = storage.ticked ? storage.added.byteOffset : 0;
         record[base + storageChanged] = storage.ticked ? storage.changed.byteOffset : 0;
         record[base + storageChunkAdded] = storage.ticked ? storage.chunkAdded.byteOffset : 0;
         record[base + storageChunkChanged] = storage.ticked ? storage.chunkChanged.byteOffset : 0;
         record[base + storageChunks] = storage.chunkAdded.length;
+        record[base + storageBlockAdded] = storage.ticked ? storage.blockAdded.byteOffset : 0;
+        record[base + storageBlockChanged] = storage.ticked ? storage.blockChanged.byteOffset : 0;
     }
     Atomics.store(record, recordVersion, archetype.version);
     // Entered once complete, so a reader that finds it finds a whole record.
@@ -169,13 +218,16 @@ export const flushDirectory = (directory: LayoutDirectory | null, bumped: Archet
         directory.entities = entities.version;
     }
     if (bumped.length === 0) return;
+    let replaced = false;
     for (let k = 0; k < bumped.length; k++) {
         const archetype = bumped[k];
         archetype.listed = false;
+        if (directory.records[archetype.id] !== undefined) replaced = true;
         writeArchetype(directory, archetype);
     }
     bumped.length = 0;
     Atomics.store(directory.header, tableLengthWord, archetypes.length);
+    if (replaced) Atomics.add(directory.header, replacedWord, 1);
 };
 
 /**

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import type * as Fixture from "./lifetime.fixture.js";
 
@@ -7,7 +8,7 @@ export const lifetimeCases = (load: () => Promise<typeof Fixture>) => describe("
         const fixture = await load();
         const { before, after, collected, total, ran } = await fixture.freshKernels(200);
         expect(total).toBe(fixture.rows - 1);
-        // Its report counts the kernel's run and the workers it ran on.
+        // Its run counts the kernel and the workers it ran on.
         expect({ systems: ran.systems, workers: ran.workers, joined: ran.joined, gpu: ran.gpu }).toEqual({ systems: 1, workers: 2, joined: 0, gpu: false });
         expect(before.workers).toHaveLength(2);
         // Workers keep a kernel by its code, so new values of it add nothing there, collected or not.

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

@@ -1,13 +1,12 @@
-import { Component } from "../../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Entity } from "../../interface/entity/entity.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { System } from "../../interface/system/system.js";
 import { workers } from "../../interface/resources/workers.js";
 import { createWorld, type Tables } from "./create.js";
 import { collector, freshKernel, tablesAfterCollecting } from "./lifetime.test-helper.js";
 import { readResource } from "./reads.test-helper.js";
-import { fillReports, runOf } from "./reports.test-helper.js";
-import { Report } from "../../interface/report/report.js";
+import { runRan, type Ran } from "./outcomes.test-helper.js";
+import type { F32 } from "../../interface/math/index.js";
 
 /** Scenarios of what kernels hold across the pool, run built in node and from source in chromium. */
 
@@ -18,34 +17,28 @@ const total = Symbol("lifetimeFixture/total");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [value]: { type: number };
+        [value]: { type: F32 };
         [target]: { type: Entity };
-        [out]: { type: number };
+        [out]: { type: F32 };
     }
     export interface Resources {
         [total]: { type: number; reduce: "+" };
     }
 }
 
-Component.register(value, { type: { type: "number", precision: 1 } });
-Component.register(target, { type: Entity.schema });
-Component.register(out, { type: { type: "number", precision: 1 } });
-Resource.register(total, { type: { type: "number", default: 0 }, reduce: "+" });
 
 export const rows = 4_096;
 
-const seed = System.create({ name: "lifetimeFixture/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     let previous = commands.spawn([value])({ [value]: 0 });
     for (let i = 1; i < rows; i++) previous = commands.spawn([value, target, out])({ [value]: i, [target]: previous, [out]: 0 });
 });
 
 /** A kernel that holds what kernels can: a lookup's directory, reduction partials and its load on each worker. */
 const measure = System.create({
-    name: "lifetimeFixture/measure",
-    kernel: "cpu",
-    components: { read: [value, target], write: [out] },
-    lookup: { targets: { read: [value] } },
-    reduce: { [total]: "+" },
+    kernel: true,
+    components: { with: [value, target, out] },
+    lookup: { targets: { with: [value] } },
 }, (row, { lookup: { targets }, reduce }) => {
     const other = targets(row[target]);
     row[out] = other === null ? -1 : row[value] - other[value];
@@ -56,20 +49,18 @@ const measure = System.create({
  * Runs `count` new values of a kernel, as a module evaluated again makes, each once, on two workers: the world's tables
  * before and after, once collected where a collector is exposed; whether one was; and the last run's total.
  */
-export const freshKernels = async (count: number): Promise<{ readonly before: Tables; readonly after: Tables; readonly collected: boolean; readonly total: number; readonly ran: Report[typeof Report.run] }> => {
+export const freshKernels = async (count: number): Promise<{ readonly before: Tables; readonly after: Tables; readonly collected: boolean; readonly total: number; readonly ran: Ran }> => {
     const world = createWorld({ [workers]: 2 }, { minimumChunk: 64 });
     try {
         await world.run(seed);
-        // Past the runs that spawn reports, which grow the entity table.
-        await fillReports(world);
         await world.run(measure);
         await world.run(freshKernel(measure));
         await world.run(measure);
         const before = await tablesAfterCollecting(world);
         for (let k = 0; k < count; k++) await world.run(freshKernel(measure));
-        const last = await world.run(measure);
+        const ran = await runRan(world, measure);
         const after = await tablesAfterCollecting(world);
-        return { before, after, collected: collector() !== null, total: await readResource(world, total), ran: await runOf(world, last) };
+        return { before, after, collected: collector() !== null, total: await readResource(world, total), ran };
     }
     finally {
         await world.dispose();

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { System } from "../../interface/system/system.js";
 import type { Leaf } from "../../interface/system/leaf.js";
 import { definitionOf } from "../../interface/registry/index.js";
@@ -72,7 +73,7 @@ export const freshKernel = (system: System): System => {
     const description = kernelOf(system);
     if (leaf === undefined || leaf.kind === "composite" || description === undefined) throw new Error("Not a kernel system.");
     // What `System.create` makes of the same declaration and body, without the id a top-level binding takes.
-    const copy: Leaf & System = { kind: leaf.kind, name: leaf.name, declaration: leaf.declaration, body: leaf.body };
+    const copy: Leaf & System = { kind: leaf.kind, name: leaf.name, declaration: leaf.declaration, input: leaf.input, body: leaf.body };
     claimSystem(copy, undefined);
     return attachKernel(copy, description);
 };

package/src/implementation/world/lifetime.test.ts

@@ -1,13 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Entity } from "../../interface/entity/entity.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
 import { workers } from "../../interface/resources/workers.js";
 import { createWorld } from "./create.js";
 import { collector, heapAfterCollecting, tablesAfterCollecting } from "./lifetime.test-helper.js";
-import { fillReports } from "./reports.test-helper.js";
 
 const count = Symbol("lifetimeTest/count");
 const parent = Symbol("lifetimeTest/parent");
@@ -19,30 +17,27 @@ declare module "@adobe/ecs" {
         [parent]: { type: Entity; reference: "owner" };
     }
     interface Resources {
-        [score]: { type: number };
+        [score]: { type: number; default: 7 };
     }
 }
 
-Component.register(count, { type: { type: "number" } });
-Component.register(parent, { type: Entity.schema, reference: "owner" });
-Resource.register(score, { type: { type: "number", default: 7 } });
 
-const seed = System.create({ name: "lifetimeTest/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     const root = commands.spawn([count])({ [count]: 1 });
     for (let i = 0; i < 4; i++) commands.spawn([count, parent])({ [count]: i, [parent]: root });
 });
 
 /** A module-level system, run between and after the fresh ones, as an app's own systems are. */
-const steady = System.create({ name: "lifetimeTest/steady", components: { read: [count], changed: [count] } }, row => { void row[count]; });
+const steady = System.create({ components: { with: [count], changed: [count] } }, row => { void row[count]; });
 
 let copied = 0;
 
 /** Fresh systems of each shape that holds something: a body alone, a resource read, a change filter, and `up`. */
 const freshSystems = (k: number): readonly System[] => [
     System.create(() => {}),
-    System.create({ resources: { read: [score] } }, ({ resources }) => { copied = resources[score] + k; }),
-    System.create({ components: { write: [count], changed: [count] } }, row => { row[count] += 1; }),
-    System.create({ components: { read: [count] }, up: { through: parent, read: [count] } }, (row, { up }) => { copied = row[count] + (up?.[count] ?? 0); }),
+    System.create({}, ({ resources }) => { copied = resources[score] + k; }),
+    System.create({ components: { with: [count], changed: [count] } }, row => { row[count] += 1; }),
+    System.create({ components: { with: [count] }, up: { through: parent } }, (row, { up }) => { copied = row[count] + (up?.[count] ?? 0); }),
 ];
 
 const fresh = 10_000;
@@ -61,8 +56,6 @@ describe("what a system holds", () => {
         expect(collector()).not.toBeNull();
         const world = createWorld({ [workers]: 0 });
         await world.run(seed);
-        // Past the runs that spawn reports, which grow the entity table.
-        await fillReports(world);
         await runFresh(world, 4);
         const before = await tablesAfterCollecting(world);
         await runFresh(world, fresh);