@adobe/ecs 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,84 @@
+import { Resource } from "../../interface/resource/resource.js";
+import { System } from "../../interface/system/system.js";
+import type { World } from "../../interface/world/world.js";
+
+// Keys and systems both threads of the removal tests import: systems on thread "removeTest", which a joined thread
+// fills, the first of each pair removing the second from the task they run in.
+
+export const mark = Symbol("removeTest/mark");
+export const pause = Symbol("removeTest/pause");
+export const secondRuns = Symbol("removeTest/secondRuns");
+declare module "@adobe/ecs" {
+    export interface Threads {
+        removeTest: true;
+    }
+    export interface Resources {
+        [mark]: { type: { readonly text: string }; thread: "removeTest" };
+        [pause]: { type: number };
+        [secondRuns]: { type: number };
+    }
+}
+/** An object resource of the thread, which places the systems reading it there. */
+Resource.register(mark, { type: { type: "object", properties: { text: { type: "string" } }, default: { text: "m" } }, thread: "removeTest" });
+/** How long, in milliseconds, `first` and `firstTail` spin before they return. */
+Resource.register(pause, { type: { type: "number", default: 0 } });
+/** How many times `second` ran, wherever it ran. */
+Resource.register(secondRuns, { type: { type: "integer", default: 0 } });
+
+/** How many times each system's body was called on this thread. */
+export const calls = { first: 0, second: 0, firstTail: 0, secondTail: 0 };
+
+/**
+ * Where systems on this thread remove others: a world on this thread, for tests on one thread; and what `removerTail`
+ * removes next.
+ */
+export const removal: { world: World | null; armed: boolean; target: System | null } = { world: null, armed: false, target: null };
+
+const spin = (milliseconds: number): void => {
+    const end = performance.now() + milliseconds;
+    while (performance.now() < end);
+};
+
+/** Blocking, since its body reaches `commands`: a tier on the thread, and with `second`, one task. */
+export const first = System.create({ name: "removeTest/first", resources: { read: [mark, pause] } }, ({ resources, commands }) => {
+    void commands;
+    calls.first += resources[mark].text.length;
+    spin(resources[pause]);
+    if (removal.armed) removal.world?.remove(second);
+});
+
+export const second = System.create({ name: "removeTest/second", resources: { read: [mark], write: [secondRuns] }, after: [first] }, ({ resources, commands }) => {
+    void commands;
+    calls.second += resources[mark].text.length;
+    resources[secondRuns] += 1;
+});
+
+/** Terminal, so a tail, run with `secondTail` as one task after the tick's sync point. */
+export const firstTail = System.create({ name: "removeTest/firstTail", resources: { read: [mark, pause] } }, ({ resources }) => {
+    calls.firstTail += resources[mark].text.length;
+    spin(resources[pause]);
+    if (removal.armed) removal.world?.remove(secondTail);
+});
+
+/** Terminal, so a tail: removes `removal.target`, once, when it's set. */
+export const removerTail = System.create({ name: "removeTest/removerTail", resources: { read: [mark] } }, ({ resources }) => {
+    void resources[mark];
+    const { target } = removal;
+    removal.target = null;
+    if (target !== null) removal.world?.remove(target);
+});
+
+export const secondTail = System.create({ name: "removeTest/secondTail", resources: { read: [mark] }, after: [firstTail] }, ({ resources }) => {
+    calls.secondTail += resources[mark].text.length;
+});
+
+/**
+ * On the world's thread, added while the others come and go, so ticks go on; after `second`, so the tiers of `first` and
+ * `second` are one task there.
+ */
+export const ticking = System.create({ name: "removeTest/ticking", after: [second] }, () => {});
+
+/** Sets how long `first` and `firstTail` spin. */
+export const setPause = System.create({ name: "removeTest/setPause", input: { type: "object", properties: { milliseconds: { type: "number" } } }, resources: { write: [pause] } }, ({ input, resources }) => {
+    resources[pause] = input.milliseconds;
+});

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

@@ -0,0 +1,194 @@
+import { describe, expect, it } from "vitest";
+import { Component } from "../../interface/component/component.js";
+import { Entity } from "../../interface/entity/entity.js";
+import { Observe } from "../../observe/index.js";
+import { always } from "../../interface/resources/always.js";
+import { clock } from "../../interface/resources/clock.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, type CreatedWorld } from "./create.js";
+import { tablesAfterCollecting } from "./lifetime.test-helper.js";
+import { backToBack } from "./loop.js";
+
+const value = Symbol("removeTest/value");
+const parent = Symbol("removeTest/parent");
+const shared = Symbol("removeTest/shared");
+
+declare module "@adobe/ecs" {
+    interface Components {
+        [value]: { type: number };
+        [parent]: { type: Entity; reference: "owner" };
+        [shared]: { type: number };
+    }
+}
+
+Component.register(value, { type: { type: "number" } });
+Component.register(parent, { type: Entity.schema, reference: "owner" });
+Component.register(shared, { type: { type: "number" } });
+
+/** How many times each system's body was called. */
+const calls = { kept: 0, held: 0, alone: 0, other: 0, late: 0, self: 0, writer: 0, reader: 0 };
+/** The world the systems that remove others act on. */
+let current: World | null = null;
+/** What `selfRemoving` removes, once its body has been called this many times. */
+let removeAfter = Infinity;
+
+const seed = System.create({ name: "removeTest/seed" }, ({ commands }) => {
+    const root = commands.spawn([value, shared])({ [value]: 0, [shared]: 0 });
+    for (let i = 1; i < 10; i++) commands.spawn([value, parent, shared])({ [value]: i, [parent]: root, [shared]: 0 });
+});
+
+/** Run before tables are taken, so `value` and `parent` keep ticks then, as they do once any system filters on them. */
+const ticksValue = System.create({ name: "removeTest/ticksValue", components: { added: [value, parent] } }, () => {});
+
+/** Added for the whole of each test, so ticks go on. */
+const kept = System.create({ name: "removeTest/kept" }, () => { calls.kept++; });
+
+/** Holds what systems can on the world's thread: an `up` order, a change filter's count, command buffers. */
+const held = System.create({ name: "removeTest/held", components: { read: [value], changed: [value] }, up: { through: parent, read: [value] } }, (row, { up }) => {
+    calls.held++;
+    void (row[value] + (up?.[value] ?? 0));
+});
+
+const alone = System.create({ name: "removeTest/alone" }, () => { calls.alone++; });
+const other = System.create({ name: "removeTest/other" }, () => { calls.other++; });
+const pair = System.create({ name: "removeTest/pair", systems: [alone, other] });
+
+/** In a later tier than `remover`, which removes it during the tick. */
+const late = System.create({ name: "removeTest/late", components: { read: [value] } }, row => { calls.late += row[value] >= 0 ? 1 : 0; });
+const remover = System.create({ name: "removeTest/remover", before: [late] }, () => { current?.remove(late); });
+
+/** Removes itself partway through its rows. */
+const selfRemoving = System.create({ name: "removeTest/selfRemoving", components: { read: [value] } }, row => {
+    calls.self += row[value] >= 0 ? 1 : 0;
+    if (calls.self === removeAfter) current?.remove(selfRemoving);
+});
+
+/** Ordered only through `phase`: removing `phase` would leave them conflicting with no order between them. */
+const phase = System.create({ name: "removeTest/phase" }, () => {});
+const writer = System.create({ name: "removeTest/writer", components: { write: [shared] }, before: [phase] }, row => { calls.writer++; row[shared] += 1; });
+const reader = System.create({ name: "removeTest/reader", components: { read: [shared] }, after: [phase] }, row => { calls.reader++; void row[shared]; });
+
+/** A world ticking back to back once something is added, with `kept` added. */
+const ticking = async (): Promise<{ readonly world: CreatedWorld; readonly ticks: (count: number) => Promise<void>; readonly close: () => Promise<void> }> => {
+    const driver = backToBack();
+    const world = createWorld({ [workers]: 0, [always]: true }, { loop: driver });
+    current = world;
+    await world.run(seed);
+    world.add(kept);
+    /** Waits for `count` more ticks. */
+    const ticks = async (count: number): Promise<void> => {
+        const first = (await Observe.toPromise(Observe.resource(world, clock))).tick;
+        await new Promise<void>(resolve => {
+            const stop = Observe.resource(world, clock)(({ tick }) => {
+                if (tick < first + count) return;
+                queueMicrotask(() => stop());
+                resolve();
+            });
+        });
+    };
+    await ticks(2);
+    return { world, ticks, close: async () => { await world.dispose(); driver.close(); current = null; } };
+};
+
+describe("world.remove", () => {
+    it("never calls a removed system's body again, and releases what it held", async () => {
+        const { world, ticks, close } = await ticking();
+        await world.run(ticksValue);
+        const before = await tablesAfterCollecting(world);
+        world.add(held);
+        await ticks(3);
+        expect(calls.held).toBeGreaterThan(0);
+        world.remove(held);
+        const removed = calls.held;
+        await ticks(3);
+        expect(calls.held).toBe(removed);
+        expect(await tablesAfterCollecting(world)).toEqual(before);
+        await close();
+    });
+
+    it("keeps a system added alone and within an added composite until both are removed", async () => {
+        const { world, ticks, close } = await ticking();
+        world.add(pair);
+        world.add(alone);
+        await ticks(2);
+        world.remove(alone);
+        const [aloneThen, otherThen] = [calls.alone, calls.other];
+        await ticks(2);
+        expect(calls.alone).toBeGreaterThan(aloneThen);
+        world.remove(pair);
+        const [aloneAfter, otherAfter] = [calls.alone, calls.other];
+        await ticks(2);
+        expect([calls.alone, calls.other]).toEqual([aloneAfter, otherAfter]);
+        expect(otherAfter).toBeGreaterThan(otherThen);
+        await close();
+    });
+
+    it("does nothing for a value that isn't added, and throws for one no constructor returned", async () => {
+        const { world, ticks, close } = await ticking();
+        world.remove(other);
+        world.remove(kept);
+        world.remove(kept);
+        expect(() => world.remove({ name: "not a system" })).toThrow("isn't a system");
+        world.add(kept);
+        await ticks(1);
+        await close();
+    });
+
+    it("throws, removing nothing, when the systems left would conflict with no order between them", async () => {
+        const { world, ticks, close } = await ticking();
+        world.add(writer);
+        world.add(phase);
+        world.add(reader);
+        await ticks(1);
+        expect(() => world.remove(phase)).toThrow('both access "removeTest/shared"');
+        const [written, read] = [calls.writer, calls.reader];
+        await ticks(2);
+        expect(calls.writer).toBeGreaterThan(written);
+        expect(calls.reader).toBeGreaterThan(read);
+        world.remove(reader);
+        world.remove(phase);
+        world.remove(writer);
+        await close();
+    });
+
+    it("skips a system removed during a tick in progress from its next tier on", async () => {
+        const { world, ticks, close } = await ticking();
+        world.add(late);
+        await ticks(2);
+        const before = calls.late;
+        expect(before).toBeGreaterThan(0);
+        // In the tick `remover` runs, `late` follows it in a later tier.
+        world.add(remover);
+        await ticks(3);
+        expect(calls.late).toBe(before);
+        world.remove(remover);
+        await close();
+    });
+
+    it("calls no row of a system that removed itself partway through its rows", async () => {
+        const { world, ticks, close } = await ticking();
+        calls.self = 0;
+        removeAfter = 3;
+        world.add(selfRemoving);
+        await ticks(3);
+        expect(calls.self).toBe(3);
+        removeAfter = Infinity;
+        await close();
+    });
+
+    it("skips a removed system in a run of a composite holding it that was queued before", async () => {
+        const { world, close } = await ticking();
+        world.add(pair);
+        const ran = world.run(pair);
+        world.remove(pair);
+        const [aloneThen, otherThen] = [calls.alone, calls.other];
+        await ran;
+        expect([calls.alone, calls.other]).toEqual([aloneThen, otherThen]);
+        // Run again, it's registered anew.
+        await world.run(pair);
+        expect([calls.alone, calls.other]).toEqual([aloneThen + 1, otherThen + 1]);
+        await close();
+    });
+});

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

@@ -0,0 +1,117 @@
+import { Report } from "../../interface/report/report.js";
+import { retainedRuns } from "./reports.js";
+import { System } from "../../interface/system/system.js";
+import type { Input } from "../../interface/system/input.js";
+import type { World } from "../../interface/world/world.js";
+
+/** A run's report as data: its errors, empty when it has none, and what it dropped. */
+export type Reported = {
+    readonly failures: readonly Report.Failure[];
+    readonly skipped: readonly string[];
+    readonly dropped: number;
+    readonly warnings: readonly Report.Warning[];
+};
+
+/** By world, its reader of reports and the reads asked of it, in the order their runs run: each the run whose report it wants, and what it found. */
+type Reader = { readonly system: System; readonly asked: { readonly run: number; found: Reported | null; values: Report[typeof Report.run] | null }[] };
+const readers = new WeakMap<World, Reader>();
+
+const none: readonly never[] = [];
+
+const readerOf = (world: World): Reader => {
+    const known = readers.get(world);
+    if (known !== undefined) return known;
+    const asked: Reader["asked"] = [];
+    const system = System.create({ name: "test/readReport", observer: true, components: { read: [Report.run] }, lookup: { errorsOf: { read: [Report.errors] } } }, (row, { lookup }) => {
+        const read = asked[0];
+        const values = row[Report.run];
+        if (read === undefined || (read.run >= 0 ? values.number !== read.run : values.number <= (read.values?.number ?? -1))) return;
+        const errors = lookup.errorsOf(row.entity)?.[Report.errors] ?? null;
+        read.values = values;
+        read.found = errors === null
+            ? { failures: none, skipped: none, dropped: values.dropped, warnings: none }
+            : { failures: errors.failures, skipped: errors.skipped, dropped: values.dropped, warnings: errors.warnings };
+    });
+    const reader = { system, asked };
+    readers.set(world, reader);
+    return reader;
+};
+
+const readOf = async (world: World, run: number) => {
+    const { system, asked } = readerOf(world);
+    const read: Reader["asked"][number] = { run, found: null, values: null };
+    asked.push(read);
+    try {
+        await world.run(system);
+    }
+    finally {
+        const left = asked.indexOf(read);
+        if (left >= 0) asked.splice(left, 1);
+    }
+    return read;
+};
+
+/** Run `run`'s report, read once by an observer system's run over every report; throws when there's none. */
+export const reportOf = async (world: World, run: number): Promise<Reported> => {
+    const { found } = await readOf(world, run);
+    if (found === null) throw new Error(`Run ${run} has no report.`);
+    return found;
+};
+
+/** Run `run`'s `Report.run`; throws when it has no report. */
+export const runOf = async (world: World, run: number): Promise<Report[typeof Report.run]> => {
+    const { values } = await readOf(world, run);
+    if (values === null) throw new Error(`Run ${run} has no report.`);
+    return values;
+};
+
+/**
+ * Runs a system, then reads the next run's report, which holds what the system's run found after its own was written:
+ * what its observer pass threw.
+ */
+export const runThenNext = async <I>(world: World, system: System<I>, ...input: Input<NoInfer<I>>): Promise<Reported> => {
+    await world.run(system, ...input);
+    // The reader's own run is the newest: its report holds what was deferred to it.
+    const { found } = await readOf(world, -1);
+    if (found === null) throw new Error("The next run has no report.");
+    return found;
+};
+
+/** Runs a system, then reads its run's report. */
+export const runReported = async <I>(world: World, system: System<I>, ...input: Input<NoInfer<I>>): Promise<Reported> =>
+    reportOf(world, await world.run(system, ...input));
+
+/**
+ * Follows a world's reports with an observer system it adds: `seen` lists each report as a pass found it changed, and
+ * `until` resolves with the first one a test passes, once one does.
+ */
+export const followReports = (world: World) => {
+    type Seen = { readonly run: number; readonly failures: readonly Report.Failure[] };
+    const seen: Seen[] = [];
+    const waiting: (() => void)[] = [];
+    const system = System.create({ name: "test/followReports", observer: true, components: { read: [Report.run, Report.errors], changed: [Report.errors] } }, row => {
+        seen.push({ run: row[Report.run].number, failures: row[Report.errors].failures });
+        for (const wake of waiting.splice(0)) wake();
+    });
+    world.add(system);
+    const until = async (test: (report: Seen) => boolean): Promise<Seen> => {
+        for (;;) {
+            const found = seen.find(test);
+            if (found !== undefined) return found;
+            await new Promise<void>(resolve => waiting.push(resolve));
+        }
+    };
+    return { seen, until, stop: () => world.remove(system) };
+};
+
+/** Despawns every report, for tests that compare entity order with a world that has none: later runs spawn them again. */
+export const dropReports = System.create({ name: "test/dropReports", components: { has: [Report.run] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+});
+
+const nothing = System.create({ name: "test/nothing" }, () => {});
+
+/** Runs a world until every report it keeps is spawned, so later runs reuse their entities and spawn none. */
+export const fillReports = async (world: World): Promise<void> => {
+    for (let k = 0; k < retainedRuns; k++) await world.run(nothing);
+};

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

@@ -0,0 +1,167 @@
+import { describe, expect, it } from "vitest";
+import { Component, Index, Report, Resource, System, clock, workers } from "../../index.js";
+import { createWorld } from "./create.js";
+import { retainedRuns } from "./reports.js";
+import { reportOf, runOf } from "./reports.test-helper.js";
+
+const amount = Symbol("reportsTest/amount");
+const level = Symbol("reportsTest/level");
+declare module "@adobe/ecs" {
+    interface Components {
+        [amount]: { type: number };
+    }
+    interface Resources {
+        [level]: { type: number };
+    }
+}
+Component.register(amount, { type: { type: "number" } });
+Resource.register(level, { type: { type: "number", default: 0 } });
+
+const nothing = System.create({ name: "reportsTest/nothing" }, () => {});
+const fail = System.create({ name: "reportsTest/fail" }, () => { throw new Error("run failed"); });
+const raise = System.create({ name: "reportsTest/raise", resources: { write: [level] } }, ({ resources }) => { resources[level] += 1; });
+const idle = System.create({ name: "reportsTest/idle", observer: true }, () => {});
+const spawn = System.create({ name: "reportsTest/spawn" }, ({ commands }) => { commands.spawn([amount])({ [amount]: 1 }); });
+const despawnAll = System.create({ name: "reportsTest/despawnAll", components: { has: [amount] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+    commands.despawn(row.entity);
+});
+const failingObserver = System.create({ name: "reportsTest/failingObserver", observer: true, resources: { read: [level], changed: [level] } }, ({ resources }) => {
+    if (resources[level] > 0) throw new Error("observer failed");
+});
+
+/** What a logger following reports saw, by pass: each changed report's run and failures' messages. */
+const logged: (readonly [number, readonly string[]])[] = [];
+const logger = System.create({ name: "reportsTest/logger", observer: true, components: { read: [Report.run, Report.errors], changed: [Report.errors] } }, row => {
+    logged.push([row[Report.run].number, row[Report.errors].failures.map(failure => failure.message)]);
+});
+
+/** The run numbers of every report, in entity order, and of those with errors. */
+let numbers: number[] = [];
+let withErrors: number[] = [];
+const allReports = Index.create({ name: "reportsTest/allReports", key: [], components: { has: [Report.run] } });
+const erredReports = Index.create({ name: "reportsTest/erredReports", key: [], components: { has: [Report.run, Report.errors] } });
+const listReports = System.create({ name: "reportsTest/listReports", observer: true, lookup: { all: { index: allReports, read: [Report.run] }, erred: { index: erredReports, read: [Report.run] } } }, ({ lookup }) => {
+    const all = lookup.all();
+    numbers = [];
+    for (let i = 0; i < all.length; i++) numbers.push(all.at(i)[Report.run].number);
+    const erred = lookup.erred();
+    withErrors = [];
+    for (let i = 0; i < erred.length; i++) withErrors.push(erred.at(i)[Report.run].number);
+});
+
+const inline = () => createWorld({ [workers]: 0 });
+const sorted = (values: readonly number[]) => [...values].sort((a, b) => a - b);
+
+describe("reports", () => {
+    it("number every run in order, one of observer systems alone included, each with a report", async () => {
+        await using world = inline();
+        expect(await world.run(nothing)).toBe(1);
+        expect(await world.run(raise)).toBe(2);
+        expect(await world.run(idle)).toBe(3);
+        expect(await reportOf(world, 2)).toEqual({ failures: [], skipped: [], dropped: 0, warnings: [] });
+        const listed = await world.run(listReports);
+        expect(sorted(numbers)).toEqual([1, 2, 3, 4, listed]);
+        expect(withErrors).toEqual([]);
+    });
+
+    it("say what a run ran: its systems, on main with no joined thread claiming it, and how long it took", async () => {
+        await using world = inline();
+        const both = await world.run(System.create([nothing, raise]));
+        const values = await runOf(world, both);
+        expect({ ...values, elapsed: 0 }).toEqual({ number: both, elapsed: 0, systems: 2, workers: 0, joined: 0, main: true, gpu: false, dropped: 0 });
+        expect(values.elapsed).toBeGreaterThanOrEqual(0);
+        const alone = await runOf(world, await world.run(idle));
+        expect({ ...alone, elapsed: 0 }).toEqual({ number: alone.number, elapsed: 0, systems: 0, workers: 0, joined: 0, main: false, gpu: false, dropped: 0 });
+    });
+
+    it("give a failed run errors, which an observer system sees in that run's pass, and a dropping run only its count", async () => {
+        await using world = inline();
+        logged.length = 0;
+        world.add(logger);
+        const failed = await world.run(fail);
+        expect(logged).toEqual([[failed, ["run failed"]]]);
+        const { failures } = await reportOf(world, failed);
+        expect(failures.map(({ kind, name, message }) => [kind, name, message])).toEqual([["system", "reportsTest/fail", "run failed"]]);
+        await world.run(spawn);
+        const dropping = await world.run(despawnAll);
+        expect(await reportOf(world, dropping)).toEqual({ failures: [], skipped: [], dropped: 1, warnings: [] });
+        expect(logged).toHaveLength(1);
+        await world.run(listReports);
+        expect(withErrors).toEqual([failed]);
+        world.remove(logger);
+    });
+
+    it("write each report's errors once, an observer pass's failures in the next run's report", async () => {
+        await using world = inline();
+        logged.length = 0;
+        world.add(failingObserver);
+        world.add(logger);
+        const raised = await world.run(raise);
+        expect(logged).toEqual([]);
+        expect((await reportOf(world, raised)).failures).toEqual([]);
+        // The reader's run, the next, holds them, and the logger saw them in its pass.
+        const { failures } = await reportOf(world, raised + 1);
+        expect(failures.map(({ name, message }) => [name, message])).toEqual([["reportsTest/failingObserver", "observer failed"]]);
+        expect(logged).toEqual([[raised + 1, ["observer failed"]]]);
+        // A failed run's report holds its own failures; its pass's are in the next.
+        const both = System.create([fail, raise]);
+        const failed = await world.run(both);
+        expect((await reportOf(world, failed)).failures.map(({ message }) => message)).toEqual(["run failed"]);
+        expect((await reportOf(world, failed + 1)).failures.map(({ message }) => message)).toEqual(["observer failed"]);
+        expect(logged.slice(1)).toEqual([[failed, ["run failed"]], [failed + 1, ["observer failed"]]]);
+    });
+
+    it(`keep the last ${retainedRuns} runs' reports, a later run taking the oldest one's entity and dropping its errors`, async () => {
+        await using world = inline();
+        const first = await world.run(fail);
+        const second = await world.run(fail);
+        while (await world.run(nothing) < first + retainedRuns - 2);
+        await world.run(listReports);
+        expect(numbers).toHaveLength(retainedRuns);
+        expect(sorted(withErrors)).toEqual([first, second]);
+        // This run takes the first report's entity, and its errors go.
+        const next = await world.run(listReports);
+        expect(numbers).toHaveLength(retainedRuns);
+        expect(sorted(numbers)[0]).toBe(second);
+        expect(sorted(numbers).at(-1)).toBe(next);
+        expect(withErrors).toEqual([second]);
+    });
+
+    it("write a reused report's errors in place when its run has errors too, and a logger sees each run's own", async () => {
+        await using world = inline();
+        logged.length = 0;
+        world.add(logger);
+        const failWith = System.create({ name: "reportsTest/failWith", input: { type: "object", properties: { k: { type: "integer" } } } }, ({ input }) => { throw new Error(`run ${input.k}`); });
+        for (let k = 0; k < retainedRuns; k++) await world.run(failWith, { k });
+        logged.length = 0;
+        const reused = await world.run(failWith, { k: retainedRuns });
+        expect(logged).toEqual([[reused, [`run ${retainedRuns}`]]]);
+        expect((await reportOf(world, reused)).failures.map(({ message }) => message)).toEqual([`run ${retainedRuns}`]);
+        await world.run(listReports);
+        expect(numbers).toHaveLength(retainedRuns);
+        world.remove(logger);
+    });
+
+    it("number ticks with runs, apart from the clock's tick, and report a failing tick's systems", async () => {
+        await using world = inline();
+        logged.length = 0;
+        world.add(logger);
+        world.add(fail);
+        let ticked = (): void => {};
+        // Its first pass passes its filter; only a tick writes the clock after.
+        let passes = 0;
+        const watchTicks = System.create({ name: "reportsTest/watchTicks", observer: true, resources: { changed: [clock] } }, () => {
+            if (++passes > 1) ticked();
+        });
+        world.add(watchTicks);
+        const tick = new Promise<void>(resolve => { ticked = resolve; });
+        const run = await world.run(nothing);
+        await tick;
+        const next = await world.run(nothing);
+        expect(next).toBeGreaterThan(run + 1);
+        const tickRuns = logged.map(([number]) => number).filter(number => number > run && number < next);
+        expect(tickRuns.length).toBeGreaterThan(0);
+        expect(logged.find(([number]) => number === tickRuns[0])?.[1]).toEqual(["run failed"]);
+    });
+});