@adobe/ecs 0.1.0 → 0.2.1

package/dist/implementation/world/create.js

@@ -8,13 +8,11 @@ import { readCell, writeCell } from './cells.js';
 import { finalizeAll, refreshFinalizerIndexes } from './finalizers.js';
 import { startWatches } from './indexes.js';
 import { clean as cleanReport, execute } from './execute.js';
-import { createReports } from './reports.js';
-import { synchronizeAlone } from './synchronize.js';
+import { errorOfRun, failureOf } from './failures.js';
+import { createOutOfBand } from './out-of-band.js';
 import { startRan } from './state.js';
-import { keysOf } from './remote-systems.js';
-import { Report } from '../../interface/report/report.js';
 import { joinedIn, runObserver } from './observer.js';
-import { joinedRunOf, postObserver, settlePosts, settleObserverKeys } from './joined-observer.js';
+import { awaitPost, joinedRunOf, postObserver, settlePosts, settleObserverKeys } from './joined-observer.js';
 import { settleKeys } from './tails.js';
 import { sharedMemoryAvailable } from './memory.js';
 import { createPool } from './pool.js';
@@ -25,27 +23,99 @@ import { refreshDirectories } from './directories.js';
 import { createRegistrar } from './register.js';
 import { ensureResources, findResource, initialOf, setResource } from './resources.js';
 import { ensureProgramResources, activate, finalizerCrossing, placeFinalizers } from './activate.js';
-import { firstKeyOf, isObserver, isWorldWritten, kindOf, orderKeysOf, programVersion, scheduleOf } from '../../interface/registry/index.js';
+import { isObserver, isWorldWritten, kindOf, programVersion, scheduleOf } from '../../interface/registry/index.js';
 import { always } from '../../interface/resources/always.js';
 import { cadence } from '../../interface/resources/cadence.js';
 import { clock } from '../../interface/resources/clock.js';
 import { wake } from '../../interface/resources/wake.js';
 import { stampChanged } from './archetype.js';
-import { failureOf } from './failures.js';
 import { createLoop, platformFrame, platformTimer } from './loop.js';
+import { presetLevelsOf } from './lists.js';
 import { createState, defaultOf, idOf, reside, startTicking } from './state.js';
 import { indexOf } from './entities.js';
+import { touchedHeld } from './up.js';
 import { isHeld } from './transfers.js';
-import { labelOf, labelOfItem } from '../../interface/registry/index.js';
-/** Runs tasks one at a time, in call order; a failed task doesn't block the next. */
+import { labelOf, whyUnregistered } from '../../interface/registry/index.js';
+const thrownValues = new WeakSet();
+const thrownOf = (error) => {
+    const wrapped = { thrown: error };
+    thrownValues.add(wrapped);
+    return wrapped;
+};
+const isThrown = (value) => typeof value === "object" && value !== null && thrownValues.has(value);
+/** What a task's caller gets: its value, or its failure thrown. */
+const unwrap = (value) => {
+    if (isThrown(value))
+        throw value.thrown;
+    return value;
+};
+/**
+ * Runs tasks one at a time, in call order; a failed task doesn't block the next. The queue's own chain never rejects,
+ * carrying a failure as a value, and the promise a task's caller holds is a second one, which nothing in the queue
+ * handles, so a rejection nobody awaits is unhandled, whatever follows it. Tasks wait in order in an array, which one
+ * shared step takes from, so queuing one makes no closure.
+ */
 const createQueue = () => {
     let tail = Promise.resolve();
-    return task => {
-        const result = tail.then(task);
-        tail = result.then(() => undefined, () => undefined);
-        return result;
+    const tasks = [];
+    let count = 0;
+    let next = 0;
+    const step = () => {
+        const k = next++;
+        const task = tasks[k];
+        // Let go, so the queue holds a task only until it starts; the slots past the last are reused.
+        tasks[k] = undefined;
+        if (next === count)
+            next = count = 0;
+        if (task === undefined)
+            return undefined;
+        try {
+            const value = task();
+            return value instanceof Promise ? value.then(undefined, thrownOf) : value;
+        }
+        catch (error) {
+            return thrownOf(error);
+        }
+    };
+    return (task) => {
+        tasks[count++] = task;
+        const settled = tail.then(step);
+        tail = settled;
+        // What `unwrap` gives is the task's own value, a `T`, or it throws.
+        return settled.then(unwrap);
     };
 };
+const recorders = new WeakMap();
+/** For tests: a world's recorder of outcomes, which it keeps from the first call on. */
+export const recorderOf = (world) => {
+    const start = recorders.get(world);
+    if (start === undefined)
+        throw new Error("Only a world createWorld made records outcomes.");
+    return start();
+};
+/** What a world holds of shared values, for `tables`. */
+const sharingHeld = (state) => {
+    let pooled = 0;
+    for (const pool of state.pools.values())
+        pooled += pool.length;
+    let values = 0;
+    for (const interned of state.shared)
+        values += interned?.byText.size ?? 0;
+    let presets = 0;
+    for (const shape of state.shapes)
+        presets += presetLevelsOf(shape);
+    return { pooled, membership: state.membership.base + state.membership.log.length, values, batches: state.batches.length, presets };
+};
+const tickers = new WeakMap();
+/** For tests: moves a world's tick on to `tick` before it ran anything, as a long-running world's would be. */
+export const startTicksAt = (world, tick) => {
+    const start = tickers.get(world);
+    if (start === undefined)
+        throw new Error("Only a world createWorld made starts its ticks elsewhere.");
+    start(tick);
+};
+/** What fails starting the pool: the workers, always the same subject, so a pool failing again isn't reported again. */
+const poolWorkers = { name: "workers", id: null };
 /** The loop's state, added to a world when its first tick runs. */
 const loopResources = [cadence, always, wake, clock];
 /**
@@ -68,10 +138,12 @@ const withFailures = (report, failures) => failures === null ? report : { ...rep
 const withTails = (report, { failures, skipped }) => failures === null && skipped === null ? report : {
     ...report, failures: failures === null ? report.failures : [...report.failures, ...failures], skipped: skipped === null ? report.skipped : [...report.skipped, ...skipped],
 };
-/** Report components, by their first keys, for knowing which systems read reports. */
-const reportKeys = new Set(Report.Archetype.map(firstKeyOf));
-/** Whether leaves read reports: name a report component in their declarations, lookups or order. */
-const readReports = (leaves) => leaves.some(leaf => [...keysOf(leaf), ...orderKeysOf(leaf.declaration)].some(key => reportKeys.has(firstKeyOf(key))));
+/** A list, or null for an empty one. */
+const listed = (list) => list.length === 0 ? null : list;
+/** Whether `subject` is what one of `failures` failed. */
+const failedIn = (failures, subject) => failures !== null && failures.some(failure => failure.subject === subject);
+/** What no joined thread gave a run: its value is its runner's. */
+const nothingThere = Symbol("nothing there");
 /** Creates a world on this thread, as `World.create` does, with options for tests and benchmarks. */
 export const createWorld = (resources = {}, options = {}) => {
     const shared = sharedMemoryAvailable();
@@ -79,15 +151,16 @@ export const createWorld = (resources = {}, options = {}) => {
     // String keys are never a resource's, so they're ignored, as commands ignore them.
     for (const key of Object.getOwnPropertySymbols(resources)) {
         if (kindOf(key) !== "resource")
-            throw new Error(`"${labelOf(key)}" isn't a registered resource.`);
+            throw new Error(`"${labelOf(key)}" isn't a registered resource: ${whyUnregistered(key)}.`);
         if (isWorldWritten(key))
             throw new Error(`"${labelOf(key)}" is written only by the world.`);
         initial.set(key, Reflect.get(resources, key));
     }
     const device = resources[gpuDevice] ?? null;
     const state = createState(shared, options.wasm ?? true, options.simd ?? true, device !== null, initial);
+    const outOfBand = createOutOfBand();
     if (device !== null)
-        state.gpu = createGpu(device);
+        state.gpu = createGpu(device, outOfBand);
     const registrar = createRegistrar(state);
     const enqueue = createQueue();
     /** Where pool workers come from; none without shared memory. */
@@ -98,7 +171,6 @@ export const createWorld = (resources = {}, options = {}) => {
     let pool = null;
     const context = {
         state, runnerOf: registrar.runnerOf, kernelIndexOf: registrar.kernelIndexOf, workers: null, publish: () => { }, tails: null,
-        beforeSync: (failures, skipped, warnings, warningCount) => reports.beforeSync(failures, skipped, warnings, warningCount),
     };
     /** Waits for every joined thread's task in flight, as a tail may be, before what moves rows a tail may still read. */
     const drainTails = async () => {
@@ -111,6 +183,7 @@ export const createWorld = (resources = {}, options = {}) => {
     };
     let disposed = false;
     const ensured = { version: -1 };
+    const minimumChunk = options.minimumChunk ?? defaultMinimumChunk;
     /** Starts the pool with as many of the wanted workers as the platform has, or none: then kernels run here. */
     const startPool = () => {
         const ports = [];
@@ -121,12 +194,15 @@ export const createWorld = (resources = {}, options = {}) => {
             ports.push(port);
         }
         workerCount = state.workers = ports.length;
-        if (ports.length === 0)
+        if (ports.length === 0) {
+            followPoolThreshold();
             return null;
+        }
         const started = createPool(ports, state.memory);
         pool = started;
-        context.workers = { pool: started, minimumChunk: options.minimumChunk ?? defaultMinimumChunk, next: 0 };
+        context.workers = { pool: started, minimumChunk, next: 0 };
         context.publish = createPublisher(state, started);
+        followPoolThreshold();
         return started;
     };
     /**
@@ -141,9 +217,52 @@ export const createWorld = (resources = {}, options = {}) => {
         workersBehind = true;
         return loadAll(runners);
     };
-    /** Gives workers every kernel whose main-thread load is newer than theirs, including ones a failed registration reloaded. */
+    /** Whether kernels failed to load on the workers a run started: then they run here, and no pool starts again. */
+    let workersFailed = false;
+    /** Whether an archetype a kernel matches has rows enough for workers, as kernels loading look before the pool starts. */
+    const kernelsWarrant = () => {
+        for (const runner of registrar.kernels())
+            for (const archetype of runner.matched())
+                if (archetype.count >= state.poolThreshold)
+                    return true;
+        return false;
+    };
+    /** Lets kernels running here want the pool, at half a piece, while one could start; once started, none want it. */
+    const followPoolThreshold = () => {
+        state.poolThreshold = pool === null && workerCount > 0 && !workersFailed ? minimumChunk / 2 : Infinity;
+        state.poolWanted = false;
+    };
+    followPoolThreshold();
+    /**
+     * Starts the pool after a run whose kernel ran here over rows enough for workers. Kernels failing to load on it are
+     * reported out of band, and the pool ends, so kernels run here from then on rather than every
+     * run trying again.
+     */
+    const startWorkers = async () => {
+        try {
+            await loadOnWorkers();
+        }
+        catch (error) {
+            workersFailed = true;
+            workersBehind = false;
+            const failed = pool;
+            pool = null;
+            context.workers = null;
+            context.publish = () => { };
+            for (const runner of registrar.kernels())
+                runner.kernel?.unloadedOnWorkers();
+            if (failed !== null)
+                void failed.terminate();
+            outOfBand.report(failureOf("workers", poolWorkers, error));
+        }
+        followPoolThreshold();
+    };
+    /**
+     * Gives workers every kernel whose main-thread load is newer than theirs, including ones a failed registration
+     * reloaded, starting the pool once a kernel ran here over rows enough for workers.
+     */
     const loadOnWorkers = async () => {
-        if (workerCount === 0 || !workersBehind)
+        if (workerCount === 0 || !workersBehind || (pool === null && !state.poolWanted && !kernelsWarrant()))
             return;
         const behind = registrar.kernels().filter(runner => runner.kernel?.staleOnWorkers() === true);
         if (behind.length === 0) {
@@ -237,7 +356,7 @@ export const createWorld = (resources = {}, options = {}) => {
             await current.readback();
             current.destroy();
         }
-        state.gpu = device === null ? null : createGpu(device);
+        state.gpu = device === null ? null : createGpu(device, outOfBand);
         state.touched = device === null ? null : new Set();
         await load(registrar.placeGpuKernels());
         await loadOnWorkers();
@@ -265,6 +384,7 @@ export const createWorld = (resources = {}, options = {}) => {
         if (wanted === workerCount)
             return;
         workerCount = wanted;
+        workersFailed = false;
         state.workers = wanted;
         const old = pool;
         pool = null;
@@ -273,6 +393,7 @@ export const createWorld = (resources = {}, options = {}) => {
         for (const runner of registrar.kernels())
             runner.kernel?.unloadedOnWorkers();
         workersBehind = true;
+        followPoolThreshold();
         // The old pool releases its control state once its workers have left their windows; runs don't wait for it.
         if (old !== null)
             void old.terminate();
@@ -283,150 +404,242 @@ export const createWorld = (resources = {}, options = {}) => {
      * needs what a sync point does for them.
      */
     const skipsSync = () => state.gpu === null && state.channels.length === 0 && state.tails.length === 0 && state.queued.length === 0 && state.observer.count === 0;
-    /** Run numbers: every run and tick takes the next, in the order they run. */
-    let runs = 0;
-    /**
-     * Commands of reports between runs, applied as a sync point of their own once observer systems on joined threads in
-     * progress have finished; or, while tails run there, which a sync point between runs would disturb, queued for the
-     * next run's or tick's.
-     */
-    const applyAlone = (buffer) => {
-        if (state.tails.length !== 0) {
-            state.queued.push({ buffer, guarded: false });
-            return null;
-        }
-        const settling = state.observer.posts.length === 0 ? null : settlePosts(state, true);
-        if (settling === null) {
-            synchronizeAlone(state, buffer);
-            publishLayouts();
-            return null;
-        }
-        return settling.then(() => {
-            if (disposed)
-                return;
-            synchronizeAlone(state, buffer);
-            publishLayouts();
-        });
+    /** Records outcomes for tests, from the first `recorderOf` call on; null until then, so runs gather nothing for it. */
+    let recorder = null;
+    /** While recording, the records of runs queued, in order, and of the run in progress. */
+    const records = [];
+    let record = null;
+    /** Takes the record of the run starting, the next queued, as each queued run starts in order. */
+    const startRecord = () => {
+        if (recorder !== null)
+            record = records.shift() ?? null;
     };
-    const reports = createReports(state, applyAlone);
-    const reportIds = [idOf(state, Report.run)];
-    const noIds = [];
-    /** A tick's report, its slot and what it ran, which `perform` leaves without `pass`, with its tails in `tailing`. */
-    let performed = cleanReport;
-    let performedSlot = null;
-    let performedValues = null;
-    /** What the last run ran, for its report, reused run to run: a tick whose report waits for its tails copies it. */
-    const ranValues = { number: 0, elapsed: 0, systems: 0, workers: 0, joined: 0, main: false, gpu: false, dropped: 0 };
-    /** What run `run` ran, gathered by its tiers, once its sync point is done, into `ranValues`. */
-    const valuesOf = (run, started, dropped) => {
+    /** What a run or tick went through, for the recorder. */
+    const outcomeOf = (report) => {
         const { ran } = state;
-        ranValues.number = run;
-        ranValues.elapsed = performance.now() - started;
-        ranValues.systems = ran.systems;
-        ranValues.workers = context.workers?.pool.takePosted() ?? 0;
-        ranValues.joined = ran.joined.size;
-        ranValues.main = ran.main;
-        ranValues.gpu = ran.gpu;
-        ranValues.dropped = dropped;
-        return ranValues;
+        return { ...report, systems: ran.systems, workers: context.workers?.pool.takePosted() ?? 0, joined: ran.joined.size, main: ran.main, gpu: ran.gpu };
     };
+    /** A run's or tick's tails, which `execution` leaves here for its caller. */
+    let tailing = null;
     /**
-     * Writes a run's report into its slot after the run's sync point, its errors with it: once tails on joined threads
-     * reading reports have copied them, and observer systems there reading them have finished.
+     * Runs a registered system or composite, its `schedule`, ending in a sync point, and gives what went wrong; its
+     * tails are left in `tailing`. A run with nothing to wait for gives it at once, allocating no async frame; a step
+     * that waits goes on, once that's done, in a function of its own.
      */
-    const writeReport = (slot, values, report) => {
-        if (disposed)
-            return null;
-        const tails = state.tails.length === 0 ? null : settleKeys(state, reportIds, noIds);
-        const posts = state.observer.posts.length === 0 ? null : settleObserverKeys(state, reportIds, noIds);
-        if (tails === null && posts === null)
-            return reports.finish(slot, values, report, state.tails.length !== 0, defer);
-        return Promise.all([tails, posts]).then(() => disposed ? undefined : reports.finish(slot, values, report, state.tails.length !== 0, defer) ?? undefined);
+    const execution = (definition, value, schedule) => {
+        const preparing = prepareRun();
+        if (preparing !== null)
+            return executePrepared(preparing, definition, value, schedule);
+        return executeRun(definition, value, schedule);
     };
-    /** Puts failures into the next run's or tick's report: those found once a report's errors were written. */
-    const defer = (failures) => {
-        (observerFailures ??= []).push(...failures);
+    const executePrepared = async (preparing, definition, value, schedule) => {
+        await preparing;
+        return executeRun(definition, value, schedule);
     };
-    /**
-     * Runs a registered system or composite, ending in a sync point, and resolves to its number. With `pass`, its
-     * report is written once its tails are done, then observer systems run, their failures added to it; without, its
-     * report is left in `performed` and its tails in `tailing`. One async step for all, so a run awaits nothing more.
-     * `registered` is its schedule as it was registered, which it runs if a system it holds was removed since,
-     * skipping that system.
-     */
-    const perform = async (definition, value, pass, registered) => {
+    /** Follows what changed since the last run: program resources, change watches, workers and the device; null when nothing did. */
+    const prepareRun = () => {
         // Resources added between runs move the resource entity, whose structs a tail may still read.
         if (ensured.version !== programVersion() && (state.channels.length > 0 || state.observer.posts.length > 0))
-            await drainTails();
+            return drainThenPrepare();
         ensureProgramResources(state, ensured);
         if (startWatches(state))
-            await reloadStamped();
+            return followChanges(true, false);
         if (workersChanged())
+            return followChanges(false, true);
+        if (deviceChanged())
+            return followChanges(false, false);
+        return null;
+    };
+    const drainThenPrepare = async () => {
+        await drainTails();
+        ensureProgramResources(state, ensured);
+        await followChanges(startWatches(state), false);
+    };
+    /**
+     * Reloads kernels for new stamps when `reload`, then follows the workers, when `workers` says a check found they
+     * changed or a check now does, and the device.
+     */
+    const followChanges = async (reload, workers) => {
+        if (reload)
+            await reloadStamped();
+        if (workers || workersChanged())
             await followWorkers();
         if (deviceChanged())
             await followDevice();
-        const schedule = registrar.registered(definition) ?? registered;
-        if (schedule === undefined)
-            throw new Error(`System "${labelOfItem(definition)}" didn't register.`);
+    };
+    /** Runs its tiers and sync point, or for a run of observer systems alone with nothing to sync, only counts what it ran. */
+    const executeRun = (definition, value, schedule) => {
         // An input that moved to a joined thread runs only there: that thread went since, its claims with it.
         if (isHeld(value) && (definition.kind === "composite" || registrar.runnerOf(definition).remote?.channel !== value.channel)) {
-            throw new Error(`System "${labelOfItem(definition)}": the run's input moved to a joined thread that's gone.`);
+            throw new Error(`System "${definition.name}": the run's input moved to a joined thread that's gone.`);
         }
-        const run = ++runs;
-        const started = performance.now();
-        // A run of observer systems alone has an empty sync point.
-        const empty = schedule.tiers.length === 0 && skipsSync();
-        // Its report's entity, spawned or reused by commands its own sync point applies, or for an empty one, applied
-        // alone, which leaves other commands for the next.
-        let slot = empty ? reports.beginAlone(run) : reports.begin(run);
-        if (slot instanceof Promise)
-            slot = await slot;
         let report;
-        let tails = null;
         try {
-            if (empty) {
+            if (schedule.tiers.length === 0 && skipsSync()) {
                 startRan(state.ran);
                 report = cleanReport;
             }
             else
-                report = await execute(context, schedule, value, definition);
+                report = execute(context, schedule, value, definition);
         }
-        finally {
-            tails = context.tails;
-            context.tails = null;
-            if (deviceChanged())
-                await followDevice();
+        catch (error) {
+            return executeFailed(error);
         }
-        const values = valuesOf(run, started, report.dropped);
-        if (!pass) {
-            tailing = tails;
-            performed = report;
-            performedSlot = slot;
-            performedValues = values;
-            return run;
+        if (report instanceof Promise)
+            return executing(report);
+        return executed(report);
+    };
+    const executing = async (running) => {
+        let report;
+        try {
+            report = await running;
+        }
+        catch (error) {
+            return executeFailed(error);
         }
-        // A run is a transaction: it ends once its tails have.
+        return executed(report);
+    };
+    /** A run whose tiers or sync point threw: it follows the device all the same, then fails. */
+    const executeFailed = async (error) => {
+        context.tails = null;
+        if (deviceChanged())
+            await followDevice();
+        throw error;
+    };
+    /** Takes the run's tails, then follows the device and starts the pool when they changed or were asked for. */
+    const executed = (report) => {
+        tailing = context.tails;
+        context.tails = null;
+        // A kernel that ran here over rows enough for workers asked for the pool, which the next run's kernels use.
+        if (deviceChanged() || (state.poolWanted && workersBehind))
+            return following(report);
+        return report;
+    };
+    const following = async (report) => {
+        if (deviceChanged())
+            await followDevice();
+        if (state.poolWanted && workersBehind)
+            await startWorkers();
+        return report;
+    };
+    /**
+     * Runs a registered system or composite as `run` does: its tiers and sync point, then once its tails are done its
+     * observer systems and those added; then gives what its per-run body returned, or throws naming what failed.
+     * `registered` is its schedule as it was registered, which it runs if a system it holds was removed since, skipping
+     * that system.
+     */
+    const perform = (definition, value, registered) => {
+        state.wanted = definition.kind === "system" && definition.declaration.components === undefined ? definition : null;
+        const schedule = registrar.registered(definition) ?? registered;
+        if (schedule === undefined)
+            throw new Error(`System "${definition.name}" didn't register.`);
+        const report = execution(definition, value, schedule);
+        if (report instanceof Promise)
+            return performing(report, definition, value, schedule);
+        return afterExecution(report, definition, value, schedule);
+    };
+    const performing = async (running, definition, value, schedule) => afterExecution(await running, definition, value, schedule);
+    /** Waits for the run's tails, as a run ends once they have, then runs observer systems. */
+    const afterExecution = (report, definition, value, schedule) => {
+        const tails = tailing;
+        tailing = null;
         if (tails !== null)
-            report = withTails(report, await tails);
-        report = withFailures(report, takeFailures());
-        const writing = writeReport(slot, values, report);
-        if (writing !== null)
-            await writing;
-        const passed = passObserver(schedule.observer, loop.observer(), joinedRunOf(value));
-        const failures = passed instanceof Promise ? await passed : passed;
-        if (failures !== null)
-            defer(failures);
-        return run;
+            return afterTails(tails, report, definition, value, schedule);
+        return passRun(report, definition, value, schedule);
     };
+    const afterTails = async (tails, report, definition, value, schedule) => passRun(withTails(report, await tails), definition, value, schedule);
     /**
-     * Failures for the next run's or tick's report: of registering observer systems `add` was given, and those joined
-     * threads report between runs.
+     * Runs the run's observer systems and those added, then settles the run: once its own on joined threads ran there,
+     * for a run of the world's, which a joined thread's run of its own doesn't wait for.
      */
-    let observerFailures = null;
-    const takeFailures = () => {
-        const failures = observerFailures;
-        observerFailures = null;
-        return failures;
+    const passRun = (report, definition, value, schedule) => {
+        const run = joinedRunOf(value);
+        const waits = run === 0 && state.observer.count !== 0 ? awaitThere(schedule.observer) : null;
+        const passed = passObserver(schedule.observer, loop.observer(), run);
+        if (waits !== null)
+            return passingThere(passed, waits, report, definition, schedule);
+        if (passed instanceof Promise)
+            return passing(passed, report, definition, schedule);
+        return settleRun(report, passed, definition, schedule, nothingThere);
+    };
+    const passing = async (passing, report, definition, schedule) => settleRun(report, await passing, definition, schedule, nothingThere);
+    /** A run's own observer systems on joined threads, each with the wait for its post, registered before it's posted. */
+    const awaitThere = (own) => {
+        let waits = null;
+        for (const leaf of own) {
+            const { joined } = registrar.runnerOf(leaf);
+            if (joined !== null)
+                (waits ??= []).push(awaitPost(state, joined, leaf === state.wanted).then((result) => [leaf, result]));
+        }
+        return waits;
+    };
+    /** How many runs wait for posts on joined threads, during which a post owed to one is posted again at once. */
+    let waitingThere = 0;
+    const passingThere = async (passing, waits, report, definition, schedule) => {
+        let passed;
+        let results;
+        waitingThere++;
+        try {
+            passed = passing instanceof Promise ? await passing : passing;
+            results = await Promise.all(waits);
+        }
+        finally {
+            waitingThere--;
+        }
+        let there = null;
+        let given = nothingThere;
+        for (const [leaf, result] of results) {
+            if (result.error !== undefined)
+                (there ??= []).push(failureOf(result.gone ? "thread" : "system", leaf, result.error));
+            else if (leaf === state.wanted)
+                given = result.value;
+        }
+        return settleRun(withFailures(report, there), passed, definition, schedule, given);
+    };
+    /**
+     * Settles a run once its observer systems ran: what its own threw fails it, as does a unique index's conflict its
+     * pass found, and what those added threw is reported out of band. Throws naming its failures, or gives what its
+     * per-run body returned: `given` from a joined thread, or else its runner's.
+     */
+    const settleRun = (report, passed, definition, schedule, given) => {
+        let own = null;
+        let added = null;
+        if (passed !== null) {
+            for (const failure of passed) {
+                if (failure.kind === "index" || schedule.observer.some(leaf => leaf === failure.subject))
+                    (own ??= []).push(failure);
+                else
+                    (added ??= []).push(failure);
+            }
+        }
+        endPass(loop.observer(), added);
+        const settled = withFailures(report, own);
+        if (recorder !== null) {
+            const outcome = outcomeOf(settled);
+            if (record !== null)
+                record.outcome = outcome;
+            for (const listener of recorder.each)
+                listener(outcome);
+        }
+        const { wanted } = state;
+        state.wanted = null;
+        const value = wanted === null ? undefined : given !== nothingThere ? given : registrar.runnerOf(wanted).takeResult();
+        if (settled.failures.length !== 0)
+            throw errorOfRun(settled);
+        return value;
+    };
+    /**
+     * After a pass: what observer systems added threw is reported out of band, and those reported before that ran
+     * their bodies in it without failing recovered.
+     */
+    const endPass = (added, failures) => {
+        outOfBand.reportAll(failures);
+        if (outOfBand.size() === 0)
+            return;
+        for (const leaf of added) {
+            if (outOfBand.has(leaf) && !failedIn(failures, leaf) && registrar.runnerOf(leaf).didRun())
+                outOfBand.recovered(leaf);
+        }
     };
     const noLeaves = [];
     const none = [];
@@ -448,17 +661,24 @@ export const createWorld = (resources = {}, options = {}) => {
         return posting === null ? failures : posting.then(() => failures);
     };
     // A post owed to a run, cancelled outside a sync point, is posted again between runs.
-    state.observer.again = () => void enqueue(async () => {
-        if (disposed)
+    state.observer.again = () => {
+        // A run waiting for a post holds the queue, so it's posted again at once.
+        if (waitingThere > 0) {
+            void postObserver(state, [], [], 0, context.workers?.pool ?? null);
             return;
-        const posting = postObserver(state, [], [], 0, context.workers?.pool ?? null);
-        if (posting !== null)
-            await posting;
-    });
+        }
+        void enqueue(async () => {
+            if (disposed)
+                return;
+            const posting = postObserver(state, [], [], 0, context.workers?.pool ?? null);
+            if (posting !== null)
+                await posting;
+        });
+    };
     /**
      * Registers an observer system `add` was given: at once when it can register again as it was
-     * (`Registrar.reregister`), otherwise before the next run, unless it was removed meanwhile; its failure is in the
-     * next pass's report.
+     * (`Registrar.reregister`), otherwise before the next run, unless it was removed meanwhile; its failure is reported
+     * out of band.
      */
     const registerObserver = (system) => {
         if (registrar.registered(system) !== undefined || registrar.reregister(system))
@@ -470,20 +690,10 @@ export const createWorld = (resources = {}, options = {}) => {
                 await complete(registrar.register(system));
             }
             catch (error) {
-                (observerFailures ??= []).push(failureOf("system", labelOfItem(system), error));
+                outOfBand.report(failureOf("system", system, error));
             }
         });
     };
-    /** Whether observer systems read reports, so a tick waits for its tails before running them. */
-    const observerReadReport = new WeakMap();
-    const readsReportOf = (leaves) => {
-        let reads = observerReadReport.get(leaves);
-        if (reads === undefined)
-            observerReadReport.set(leaves, reads = readReports(leaves));
-        return reads;
-    };
-    /** A tick's tails, which `perform` leaves for its report. */
-    let tailing = null;
     /** Writes a resource only the world writes, stamped with a tick of its own so systems see it. */
     const writeOwn = (key, value) => {
         const cell = findResource(state, key);
@@ -493,33 +703,59 @@ export const createWorld = (resources = {}, options = {}) => {
         stampChanged(cell.storage, cell.row, ++state.tick);
     };
     /**
-     * One tick: the clock, the added systems as one composite, then the tick's report, then observer systems with the
-     * tick's values, their failures in the next run's report. While its tails or an earlier tick's run, observer systems
-     * run at once, their failures in the tick's report written once those tails are done, unless one reads reports, when
-     * the tick waits for those tails first.
+     * Ends a tick once its tails are done: what failed is reported out of band, once per system while it keeps
+     * failing; what was reported and ran its body in the tick without failing recovered, as did finalizers that ran
+     * and indexes that found no conflict.
+     */
+    const endTick = (report, schedule, ran) => {
+        const { failures } = report;
+        outOfBand.reportAll(listed(failures));
+        if (outOfBand.size() !== 0) {
+            // A system a failed tier skipped didn't run, whatever its runner says of its last run.
+            if (schedule !== undefined)
+                for (const tier of schedule.tiers)
+                    for (const leaf of tier) {
+                        if (outOfBand.has(leaf) && !failedIn(failures, leaf) && !report.skipped.includes(leaf) && registrar.runnerOf(leaf).didRun())
+                            outOfBand.recovered(leaf);
+                    }
+            if (state.finalized !== null)
+                for (const finalizer of state.finalized)
+                    if (!failedIn(failures, finalizer))
+                        outOfBand.recovered(finalizer);
+            outOfBand.indexesRecovered(failures);
+        }
+        // Finalizers' runs are followed only while one is reported.
+        if (state.finalized !== null)
+            state.finalized.clear();
+        if (outOfBand.size() !== 0 || state.finalized !== null)
+            state.finalized = outOfBand.reports("finalizer") ? state.finalized ?? new Set() : null;
+        if (recorder !== null && ran !== null) {
+            const outcome = { ...ran, failures: report.failures, skipped: report.skipped, dropped: report.dropped, warnings: report.warnings };
+            for (const listener of recorder.ticks)
+                listener(outcome);
+        }
+    };
+    /**
+     * One tick: the clock, the added systems as one composite, then observer systems with the tick's values. Its
+     * tails may still run while those do; what failed is reported out of band once they're done, and what observer
+     * systems threw once they ran.
      */
     const tick = (_, clockValue) => enqueue(async () => {
         // What's added as the tick starts: systems removed since the loop asked for it aren't in it.
         const composite = loop.current();
         if (disposed || composite === null)
             return;
+        state.wanted = null;
         let report;
-        let run;
-        let slot;
-        let values;
-        const begun = runs;
+        let schedule;
         try {
             if (registrar.registered(composite) === undefined) {
                 ensureResources(state, loopResources);
                 await complete(registrar.register(composite));
             }
-            const schedule = registrar.registered(composite);
-            if (pending.length > 0 && readsReport(composite)) {
-                await Promise.all(pending.map(each => each.tails));
-                const flushing = flushReports();
-                if (flushing !== null)
-                    await flushing;
-            }
+            schedule = registrar.registered(composite);
+            if (schedule === undefined)
+                throw new Error(`System "${composite.name}" didn't register.`);
             if (state.tails.length !== 0) {
                 const waiting = settleKeys(state, [], [clockId]);
                 if (waiting !== null)
@@ -531,91 +767,27 @@ export const createWorld = (resources = {}, options = {}) => {
                     await waiting;
             }
             writeOwn(clock, clockValue);
-            run = await perform(composite, undefined, false, schedule);
-            report = performed;
-            performed = cleanReport;
-            slot = performedSlot ?? reports.lastSlot();
-            values = performedValues ?? valuesOf(run, performance.now(), 0);
-            performedSlot = performedValues = null;
+            report = await execution(composite, undefined, schedule);
         }
         catch (error) {
-            // A tick that failed before its run took a number takes one now, its report spawned between runs.
-            if (runs === begun) {
-                run = ++runs;
-                slot = await reports.beginAlone(run);
-            }
-            else {
-                run = runs;
-                slot = reports.lastSlot();
-            }
             startRan(state.ran);
-            values = valuesOf(run, performance.now(), 0);
-            report = { failures: [failureOf("system", labelOfItem(composite), error)], skipped: none, dropped: 0, warnings: none };
+            report = { failures: [failureOf("system", composite, error)], skipped: none, dropped: 0, warnings: none };
         }
-        report = withFailures(report, takeFailures());
+        const ran = recorder === null ? null : outcomeOf(cleanReport);
         const tails = tailing;
         tailing = null;
-        const observer = loop.observer();
-        if (tails !== null || pending.length > 0) {
-            if (observer.length === 0 || !readsReportOf(observer)) {
-                // Observer systems get the tick's values now; its report is written once its tails, and every earlier
-                // tick's, have run.
-                const passed = passObserver(noLeaves, observer);
-                const entry = { slot, values: { ...values }, report: withFailures(report, passed instanceof Promise ? await passed : passed), tails, done: tails === null };
-                pending.push(entry);
-                if (tails !== null)
-                    void tails.then(outcome => {
-                        entry.report = withTails(entry.report, outcome);
-                        entry.done = true;
-                        void enqueue(async () => flushReports());
-                    });
-                const flushing = flushReports();
-                if (flushing !== null)
-                    await flushing;
-                return;
-            }
-            await Promise.all(pending.map(each => each.tails));
-            const flushing = flushReports();
-            if (flushing !== null)
-                await flushing;
-            if (tails !== null)
-                report = withTails(report, await tails);
-        }
+        const ticked = schedule;
+        if (tails === null)
+            endTick(report, ticked, ran);
+        else
+            void tails.then(outcome => endTick(withTails(report, outcome), ticked, ran));
         if (disposed)
             return;
-        const writing = writeReport(slot, values, report);
-        if (writing !== null)
-            await writing;
+        const observer = loop.observer();
         const passed = passObserver(noLeaves, observer);
-        const failures = passed instanceof Promise ? await passed : passed;
-        if (failures !== null)
-            defer(failures);
+        endPass(observer, passed instanceof Promise ? await passed : passed);
     });
-    const pending = [];
-    /**
-     * Writes the reports of ticks whose tails, and every earlier tick's, have run: at once, unless one waits for
-     * observer systems in progress on joined threads, when the rest follow it.
-     */
-    const flushReports = () => {
-        while (pending.length > 0 && pending[0].done) {
-            const entry = pending.shift();
-            if (entry === undefined || disposed)
-                continue;
-            const writing = writeReport(entry.slot, entry.values, entry.report);
-            if (writing !== null)
-                return writing.then(() => flushReports() ?? undefined);
-        }
-        return null;
-    };
     const clockId = idOf(state, clock);
-    /** Whether a tick's systems read reports, so a tick waits for the last one's tails first. */
-    const readersOfReport = new WeakMap();
-    const readsReport = (composite) => {
-        let reads = readersOfReport.get(composite);
-        if (reads === undefined)
-            readersOfReport.set(composite, reads = registrar.registered(composite)?.tiers.some(readReports) ?? false);
-        return reads;
-    };
     const loop = createLoop({
         settings: () => {
             // Stored values match each resource's registered schema.
@@ -647,15 +819,55 @@ export const createWorld = (resources = {}, options = {}) => {
         // A run of observer systems alone doesn't wake the loop.
         if (scheduleOf(ran).tiers.length > 0)
             loop.arrived();
-        return enqueue(registering === null ? () => perform(ran, value, true, schedule) : async () => {
-            await complete(registering);
-            return perform(ran, value, true, schedule);
-        });
+        if (registering !== null)
+            return recorded(enqueue(() => registeredThenPerform(registering, ran, value, schedule)));
+        // Runs of registered systems wait in order in these arrays, which `performNext` takes from, so queuing one
+        // makes no closure.
+        waitingDefinitions[waitingCount] = ran;
+        waitingValues[waitingCount] = value;
+        waitingSchedules[waitingCount] = schedule;
+        waitingCount++;
+        return recorded(enqueue(performNext));
+    };
+    /** While recording, queues a record for a run just queued, found by its promise. */
+    const recorded = (running) => {
+        if (recorder === null)
+            return running;
+        const queued = { outcome: null };
+        records.push(queued);
+        recorder.runs.set(running, queued);
+        return running;
+    };
+    const registeredThenPerform = async (registering, definition, value, schedule) => {
+        startRecord();
+        await complete(registering);
+        return perform(definition, value, schedule);
+    };
+    /** Runs waiting in order, the first `waitingCount`; the slots past them are reused, never truncated. */
+    const waitingDefinitions = [];
+    const waitingValues = [];
+    const waitingSchedules = [];
+    let waitingCount = 0;
+    /** The next of them to run: the queue runs tasks in the order queued, so each `performNext` takes the next. */
+    let nextWaiting = 0;
+    const performNext = () => {
+        startRecord();
+        const k = nextWaiting++;
+        const definition = waitingDefinitions[k];
+        const value = waitingValues[k];
+        const schedule = waitingSchedules[k];
+        // Let go, so a run holds what it was given only until it starts.
+        waitingDefinitions[k] = waitingValues[k] = waitingSchedules[k] = undefined;
+        if (nextWaiting === waitingCount)
+            nextWaiting = waitingCount = 0;
+        if (definition === undefined)
+            throw new Error("A run was taken that wasn't waiting.");
+        return perform(definition, value, schedule);
     };
     const sharing = createSharing({
         state,
         run: runWith,
-        defer: (failure) => { (observerFailures ??= []).push(failure); },
+        report: failure => outOfBand.report(failure),
         crossing: (threads, imported) => registrar.crossing(threads, imported) ?? finalizerCrossing(threads, imported),
         placed: () => {
             registrar.place();
@@ -684,14 +896,13 @@ export const createWorld = (resources = {}, options = {}) => {
         },
     });
     const world = {
-        run: (system, ...args) => {
-            const [value] = args;
-            return runWith(system, value);
-        },
+        // A run gives what its system's body returned, `R` by the system's type.
+        run: (system, ...input) => runWith(system, input[0]),
         share: port => {
-            checkLive();
+            if (disposed)
+                return Promise.reject(new Error("The world is disposed."));
             if (!state.memory.shared)
-                throw new Error("Without cross-origin isolation memory can't be shared, so no thread can join.");
+                return Promise.reject(new Error("Without cross-origin isolation memory can't be shared, so no thread can join."));
             return sharing.share(port);
         },
         add: system => {
@@ -731,6 +942,8 @@ export const createWorld = (resources = {}, options = {}) => {
             disposed = true;
             loop.stop();
             return enqueue(async () => {
+                // Runs queued before have reported what failed in them; nothing is reported from here on.
+                outOfBand.close();
                 // Joined threads' runs reject from here on.
                 sharing.close();
                 // Per-query finalizers release what every live entity they match holds, reading the GPU's writes first.
@@ -768,13 +981,22 @@ export const createWorld = (resources = {}, options = {}) => {
                 phasedBuilds: state.phasedBuilds,
                 pooledBuilds: state.pooledBuilds,
                 journalReaders: state.journal.readers,
+                touched: touchedHeld(state),
                 arena: state.memory.held(),
+                archetypes: state.archetypes.length,
+                sharing: sharingHeld(state),
                 joined: state.channels.map(channel => channel.placed()),
                 gpu: state.gpu?.records() ?? 0,
                 workers: workers.map(result => ({ kernels: result.kernels ?? -1 })),
             };
         }),
     };
+    recorders.set(world, () => recorder ??= { runs: new WeakMap(), each: [], ticks: [] });
+    tickers.set(world, tick => {
+        if (state.tick !== 0)
+            throw new Error("A world starts its ticks elsewhere only before it ran anything.");
+        state.tick = tick;
+    });
     return world;
 };
 /**