@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/create.ts

@@ -1,10 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Finalizer } from '../../interface/finalizer/created.js';
 import type { Rule } from '../../interface/rule/created.js';
 import { requireDefinition, type Definition } from '../../interface/registry/index.js';
 import type { World } from '../../interface/world/world.js';
+import type { Input } from '../../interface/system/input.js';
+import type { System } from '../../interface/system/system.js';
 import type { Create, InitialResources } from '../../interface/world/create.js';
 import type { Join } from '../../interface/world/join.js';
-import type { Failure } from '../../interface/report/failure.js';
 import { joinWorld } from './join.js';
 import { createSharing, type ThreadProgress } from './sharing.js';
 import { gpuDevice } from '../../interface/resources/gpu-device.js';
@@ -14,15 +16,11 @@ import { readCell, writeCell } from './cells.js';
 import { finalizeAll, refreshFinalizerIndexes, type Thrown } from './finalizers.js';
 import { startWatches } from './indexes.js';
 import { clean as cleanReport, execute, type ExecuteContext } from './execute.js';
-import type { RunReport } from './failures.js';
-import { createReports, type RunValues, type Slot } from './reports.js';
-import { synchronizeAlone } from './synchronize.js';
+import { errorOfRun, failureOf, type Failure, type RunReport } from './failures.js';
+import { createOutOfBand } from './out-of-band.js';
 import { startRan } from './state.js';
-import type { CommandBuffer } from './buffer.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, type PostResult } from './joined-observer.js';
 import type { Leaf } from '../../interface/system/leaf.js';
 import { settleKeys, type TailOutcome } from './tails.js';
 import { sharedMemoryAvailable } from './memory.js';
@@ -36,29 +34,70 @@ import { createRegistrar, type Registration } from './register.js';
 import type { Schedule } from '../../interface/registry/schedule.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, type Composite } from '../../interface/registry/index.js';
+import { isObserver, isWorldWritten, kindOf, programVersion, scheduleOf, type Composite } from '../../interface/registry/index.js';
 import { always } from '../../interface/resources/always.js';
 import { cadence, type 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, type Clock, type LoopPlatform } from './loop.js';
+import { presetLevelsOf } from './lists.js';
 import { createState, defaultOf, idOf, reside, startTicking, type Key } from './state.js';
 import { indexOf } from './entities.js';
+import { touchedHeld } from './up.js';
 import { isHeld } from './transfers.js';
-import type { ReadonlyValue as ReadonlyResourceValue } from '../../interface/resource/value.js';
-import { labelOf, labelOfItem } from '../../interface/registry/index.js';
+import type { ReadonlyType as ReadonlyResourceType } from '../../interface/resource/value.js';
+import { labelOf, whyUnregistered } from '../../interface/registry/index.js';
 
 type Queue = <T>(task: () => T | Promise<T>) => Promise<T>;
 
-/** Runs tasks one at a time, in call order; a failed task doesn't block the next. */
+/** A task's failure as the queue's own chain carries it, which never rejects: made only when a task fails. */
+type Carried = { readonly thrown: unknown };
+const thrownValues = new WeakSet<object>();
+const thrownOf = (error: unknown): Carried => {
+    const wrapped = { thrown: error };
+    thrownValues.add(wrapped);
+    return wrapped;
+};
+const isThrown = (value: unknown): value is Carried => typeof value === "object" && value !== null && thrownValues.has(value);
+/** What a task's caller gets: its value, or its failure thrown. */
+const unwrap = (value: unknown): unknown => {
+    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 = (): Queue => {
     let tail: Promise<unknown> = Promise.resolve();
-    return task => {
-        const result = tail.then(task);
-        tail = result.then(() => undefined, () => undefined);
-        return result;
+    const tasks: ((() => unknown) | undefined)[] = [];
+    let count = 0;
+    let next = 0;
+    const step = (): unknown => {
+        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 <T>(task: () => T | Promise<T>): Promise<T> => {
+        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) as Promise<T>;
     };
 };
 
@@ -91,8 +130,17 @@ export type Tables = {
     readonly phasedBuilds: number;
     readonly pooledBuilds: number;
     readonly journalReaders: number;
+    /** Entities filtered `up`s were told changed, held until their next run. */
+    readonly touched: number;
     /** Bytes the arena holds. */
     readonly arena: number;
+    /** Archetypes it made. */
+    readonly archetypes: number;
+    /**
+     * Of shared values (`reclaim.ts`): archetypes reclaimed and waiting for reuse, how many times one was reclaimed or
+     * reused, values interned, spawn batches, and levels of spawners with constants.
+     */
+    readonly sharing: { readonly pooled: number; readonly membership: number; readonly values: number; readonly batches: number; readonly presets: number };
     /** By joined thread with claims: how many indexes there hold a system, or are held until it drops one. */
     readonly joined: readonly number[];
     /** GPU records and index blocks, 0 without a device. */
@@ -106,6 +154,58 @@ export type Tables = {
  */
 export type CreatedWorld = World & { readonly threads: (notify: (value: readonly ThreadProgress[]) => void) => () => void; readonly tables: () => Promise<Tables> };
 
+/** For tests: what a run or tick went through: what went wrong, and what it ran, where. */
+export type Outcome = RunReport & {
+    readonly systems: number;
+    readonly workers: number;
+    readonly joined: number;
+    readonly main: boolean;
+    readonly gpu: boolean;
+};
+
+/**
+ * For tests: by the promise a run returned, its outcome once its systems ran, null until then and for one that failed
+ * before they did; listeners each told every run's, joined threads' included, as it settles; and listeners each told a
+ * tick's once its tails are done.
+ */
+export type Recorder = {
+    readonly runs: WeakMap<Promise<unknown>, { outcome: Outcome | null }>;
+    readonly each: ((outcome: Outcome) => void)[];
+    readonly ticks: ((outcome: Outcome) => void)[];
+};
+
+const recorders = new WeakMap<World, () => Recorder>();
+
+/** For tests: a world's recorder of outcomes, which it keeps from the first call on. */
+export const recorderOf = (world: World): Recorder => {
+    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: ReturnType<typeof createState>): Tables["sharing"] => {
+    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<World, (tick: number) => void>();
+
+/** 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: World, tick: number): void => {
+    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: readonly Key[] = [cadence, always, wake, clock];
 
@@ -134,12 +234,14 @@ const withTails = (report: RunReport, { failures, skipped }: TailOutcome): RunRe
     ...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: ReadonlySet<Key> = new Set(Report.Archetype.map(firstKeyOf));
+/** A list, or null for an empty one. */
+const listed = <T>(list: readonly T[]): readonly T[] | null => list.length === 0 ? null : list;
+
+/** Whether `subject` is what one of `failures` failed. */
+const failedIn = (failures: readonly Failure[] | null, subject: object): boolean => failures !== null && failures.some(failure => failure.subject === subject);
 
-/** Whether leaves read reports: name a report component in their declarations, lookups or order. */
-const readReports = (leaves: readonly Leaf[]): boolean =>
-    leaves.some(leaf => [...keysOf(leaf), ...orderKeysOf(leaf.declaration)].some(key => reportKeys.has(firstKeyOf(key))));
+/** 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: InitialResources = {}, options: WorldOptions = {}): CreatedWorld => {
@@ -147,13 +249,14 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
     const initial = new Map<Key, unknown>();
     // 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.`);
+        if (kindOf(key) !== "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);
-    if (device !== null) state.gpu = createGpu(device);
+    const outOfBand = createOutOfBand();
+    if (device !== null) state.gpu = createGpu(device, outOfBand);
     const registrar = createRegistrar(state);
     const enqueue = createQueue();
     /** Where pool workers come from; none without shared memory. */
@@ -164,7 +267,6 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
     let pool: Pool | null = null;
     const context: { -readonly [K in keyof ExecuteContext]: ExecuteContext[K] } = {
         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. */
@@ -177,6 +279,8 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
     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 = (): Pool | null => {
         const ports: WorkerPort[] = [];
@@ -186,11 +290,15 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
             ports.push(port);
         }
         workerCount = state.workers = ports.length;
-        if (ports.length === 0) return null;
+        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;
     };
 
@@ -207,9 +315,51 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
         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 = (): boolean => {
+        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 = (): void => {
+        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 (): Promise<void> => {
+        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 (): Promise<void> => {
-        if (workerCount === 0 || !workersBehind) return;
+        if (workerCount === 0 || !workersBehind || (pool === null && !state.poolWanted && !kernelsWarrant())) return;
         const behind = registrar.kernels().filter(runner => runner.kernel?.staleOnWorkers() === true);
         if (behind.length === 0) {
             workersBehind = false;
@@ -275,12 +425,12 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
     const deviceId = idOf(state, gpuDevice);
     const deviceDefault = defaultOf(gpuDevice);
     /** The `gpuDevice` resource's value, read each run, so without allocating. */
-    const readDevice = (): ReadonlyResourceValue<typeof gpuDevice> => {
+    const readDevice = (): ReadonlyResourceType<typeof gpuDevice> => {
         const index = state.resourceEntity < 0 ? -1 : indexOf(state.resourceEntity);
         const storage = index < 0 ? undefined : state.archetypes[state.entities.archetype[index]]?.storageById[deviceId];
         const value = storage !== undefined ? readCell(storage, state.entities.row[index]) : state.initial.has(gpuDevice) ? state.initial.get(gpuDevice) : deviceDefault;
         // The resource's value matches its registered schema, `GPUDevice | null`.
-        return value as ReadonlyResourceValue<typeof gpuDevice>;
+        return value as ReadonlyResourceType<typeof gpuDevice>;
     };
 
     /**
@@ -305,7 +455,7 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
             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();
@@ -332,6 +482,7 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
         const wanted = platform === null ? 0 : workersOf(platform, readResource(workers));
         if (wanted === workerCount) return;
         workerCount = wanted;
+        workersFailed = false;
         state.workers = wanted;
         const old = pool;
         pool = null;
@@ -339,6 +490,7 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
         context.publish = () => {};
         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();
         await loadOnWorkers();
@@ -350,142 +502,228 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
      */
     const skipsSync = (): boolean => 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: CommandBuffer): Promise<void> | null => {
-        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: Recorder | null = null;
+    /** While recording, the records of runs queued, in order, and of the run in progress. */
+    const records: { outcome: Outcome | null }[] = [];
+    let record: { outcome: Outcome | null } | null = null;
+    /** Takes the record of the run starting, the next queued, as each queued run starts in order. */
+    const startRecord = (): void => {
+        if (recorder !== null) record = records.shift() ?? null;
     };
-    const reports = createReports(state, applyAlone);
-    const reportIds = [idOf(state, Report.run)];
-    const noIds: readonly number[] = [];
-    /** A tick's report, its slot and what it ran, which `perform` leaves without `pass`, with its tails in `tailing`. */
-    let performed: RunReport = cleanReport;
-    let performedSlot: Slot | null = null;
-    let performedValues: RunValues | null = 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: RunValues = { 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: number, started: number, dropped: number): RunValues => {
+    /** What a run or tick went through, for the recorder. */
+    const outcomeOf = (report: RunReport): Outcome => {
         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: Promise<TailOutcome> | null = 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: Slot, values: RunValues, report: RunReport): Promise<void> | null => {
-        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: Definition, value: unknown, schedule: Schedule): RunReport | Promise<RunReport> => {
+        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: readonly Failure[]): void => {
-        (observerFailures ??= []).push(...failures);
+    const executePrepared = async (preparing: Promise<void>, definition: Definition, value: unknown, schedule: Schedule): Promise<RunReport> => {
+        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: Definition, value: unknown, pass: boolean, registered: Schedule | undefined): Promise<number> => {
+    /** Follows what changed since the last run: program resources, change watches, workers and the device; null when nothing did. */
+    const prepareRun = (): Promise<void> | null => {
         // 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();
+        if (ensured.version !== programVersion() && (state.channels.length > 0 || state.observer.posts.length > 0)) return drainThenPrepare();
+        ensureProgramResources(state, ensured);
+        if (startWatches(state)) return followChanges(true, false);
+        if (workersChanged()) return followChanges(false, true);
+        if (deviceChanged()) return followChanges(false, false);
+        return null;
+    };
+    const drainThenPrepare = async (): Promise<void> => {
+        await drainTails();
         ensureProgramResources(state, ensured);
-        if (startWatches(state)) await reloadStamped();
-        if (workersChanged()) await followWorkers();
+        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: boolean, workers: boolean): Promise<void> => {
+        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: Definition, value: unknown, schedule: Schedule): RunReport | Promise<RunReport> => {
         // 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: Slot | Promise<Slot> = empty ? reports.beginAlone(run) : reports.begin(run);
-        if (slot instanceof Promise) slot = await slot;
-        let report: RunReport;
-        let tails: Promise<TailOutcome> | null = null;
+        let report: RunReport | Promise<RunReport>;
         try {
-            if (empty) {
+            if (schedule.tiers.length === 0 && skipsSync()) {
                 startRan(state.ran);
                 report = cleanReport;
             }
-            else report = await execute(context, schedule, value, definition);
+            else report = execute(context, schedule, value, definition);
+        }
+        catch (error) {
+            return executeFailed(error);
+        }
+        if (report instanceof Promise) return executing(report);
+        return executed(report);
+    };
+    const executing = async (running: Promise<RunReport>): Promise<RunReport> => {
+        let report: RunReport;
+        try {
+            report = await running;
+        }
+        catch (error) {
+            return executeFailed(error);
+        }
+        return executed(report);
+    };
+    /** A run whose tiers or sync point threw: it follows the device all the same, then fails. */
+    const executeFailed = async (error: unknown): Promise<never> => {
+        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: RunReport): RunReport | Promise<RunReport> => {
+        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: RunReport): Promise<RunReport> => {
+        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: Definition, value: unknown, registered: Schedule | undefined): unknown => {
+        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: Promise<RunReport>, definition: Definition, value: unknown, schedule: Schedule): Promise<unknown> =>
+        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: RunReport, definition: Definition, value: unknown, schedule: Schedule): unknown => {
+        const tails = tailing;
+        tailing = null;
+        if (tails !== null) return afterTails(tails, report, definition, value, schedule);
+        return passRun(report, definition, value, schedule);
+    };
+    const afterTails = async (tails: Promise<TailOutcome>, report: RunReport, definition: Definition, value: unknown, schedule: Schedule): Promise<unknown> =>
+        passRun(withTails(report, await tails), definition, value, schedule);
+
+    /**
+     * 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.
+     */
+    const passRun = (report: RunReport, definition: Definition, value: unknown, schedule: Schedule): unknown => {
+        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: Promise<Failure[] | null>, report: RunReport, definition: Definition, schedule: Schedule): Promise<unknown> =>
+        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: readonly Leaf[]): Promise<readonly [Leaf, PostResult]>[] | null => {
+        let waits: Promise<readonly [Leaf, PostResult]>[] | null = null;
+        for (const leaf of own) {
+            const { joined } = registrar.runnerOf(leaf);
+            if (joined !== null) (waits ??= []).push(awaitPost(state, joined, leaf === state.wanted).then((result): readonly [Leaf, PostResult] => [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: Failure[] | null | Promise<Failure[] | null>, waits: readonly Promise<readonly [Leaf, PostResult]>[], report: RunReport, definition: Definition, schedule: Schedule): Promise<unknown> => {
+        let passed: Failure[] | null;
+        let results: readonly (readonly [Leaf, PostResult])[];
+        waitingThere++;
+        try {
+            passed = passing instanceof Promise ? await passing : passing;
+            results = await Promise.all(waits);
         }
         finally {
-            tails = context.tails;
-            context.tails = null;
-            if (deviceChanged()) await followDevice();
+            waitingThere--;
         }
-        const values = valuesOf(run, started, report.dropped);
-        if (!pass) {
-            tailing = tails;
-            performed = report;
-            performedSlot = slot;
-            performedValues = values;
-            return run;
+        let there: Failure[] | null = null;
+        let given: unknown = 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;
         }
-        // A run is a transaction: it ends once its tails have.
-        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 settleRun(withFailures(report, there), passed, definition, schedule, given);
     };
 
     /**
-     * Failures for the next run's or tick's report: of registering observer systems `add` was given, and those joined
-     * threads report between runs.
+     * 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.
      */
-    let observerFailures: Failure[] | null = null;
-    const takeFailures = (): Failure[] | null => {
-        const failures = observerFailures;
-        observerFailures = null;
-        return failures;
+    const settleRun = (report: RunReport, passed: Failure[] | null, definition: Definition, schedule: Schedule, given: unknown): unknown => {
+        let own: Failure[] | null = null;
+        let added: Failure[] | null = 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: readonly Leaf[], failures: readonly Failure[] | null): void => {
+        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: readonly Leaf[] = [];
     const none: readonly never[] = [];
 
@@ -506,16 +744,23 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
         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) return;
-        const posting = postObserver(state, [], [], 0, context.workers?.pool ?? null);
-        if (posting !== null) await posting;
-    });
+    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;
+        }
+        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: Leaf): void => {
         if (registrar.registered(system) !== undefined || registrar.reregister(system)) return;
@@ -525,22 +770,11 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
                 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<readonly Leaf[], boolean>();
-    const readsReportOf = (leaves: readonly Leaf[]): boolean => {
-        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: Promise<TailOutcome> | null = null;
-
     /** Writes a resource only the world writes, stamped with a tick of its own so systems see it. */
     const writeOwn = (key: Key, value: unknown): void => {
         const cell = findResource(state, key);
@@ -550,31 +784,49 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
     };
 
     /**
-     * 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: RunReport, schedule: Schedule | undefined, ran: Outcome | null): void => {
+        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: 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 = (_: Composite, clockValue: Clock): Promise<void> => 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: RunReport;
-        let run: number;
-        let slot: Slot;
-        let values: RunValues;
-        const begun = runs;
+        let schedule: Schedule | undefined;
         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) await waiting;
@@ -584,84 +836,24 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
                 if (waiting !== null) 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: PendingReport = { 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);
     });
-
-    /** Ticks whose reports wait for their tails, in order. */
-    type PendingReport = { readonly slot: Slot; readonly values: RunValues; report: RunReport; readonly tails: Promise<TailOutcome> | null; done: boolean };
-    const pending: PendingReport[] = [];
-    /**
-     * 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 = (): Promise<void> | null => {
-        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<Composite, boolean>();
-    const readsReport = (composite: Composite): boolean => {
-        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: () => {
@@ -676,7 +868,7 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
     });
 
     /** Runs a system or composite with its input, as `run` does. */
-    const runWith = (system: { readonly name: string }, value: unknown): Promise<number> => {
+    const runWith = (system: { readonly name: string }, value: unknown): Promise<unknown> => {
         let registration: Registration | null = null;
         let definition: Definition | undefined;
         try {
@@ -693,16 +885,52 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
         const schedule = registrar.registered(ran);
         // 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: Promise<unknown>): Promise<unknown> => {
+        if (recorder === null) return running;
+        const queued: { outcome: Outcome | null } = { outcome: null };
+        records.push(queued);
+        recorder.runs.set(running, queued);
+        return running;
+    };
+    const registeredThenPerform = async (registering: Registration, definition: Definition, value: unknown, schedule: Schedule | undefined): Promise<unknown> => {
+        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: (Definition | undefined)[] = [];
+    const waitingValues: unknown[] = [];
+    const waitingSchedules: (Schedule | undefined)[] = [];
+    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 = (): unknown => {
+        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: Failure) => { (observerFailures ??= []).push(failure); },
+        report: failure => outOfBand.report(failure),
         crossing: (threads, imported) => registrar.crossing(threads, imported) ?? finalizerCrossing(threads, imported),
         placed: () => {
             registrar.place();
@@ -729,13 +957,11 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
     });
 
     const world: CreatedWorld = {
-        run: (system, ...args) => {
-            const [value]: readonly unknown[] = args;
-            return runWith(system, value);
-        },
+        // A run gives what its system's body returned, `R` by the system's type.
+        run: <I, R>(system: System<I, R>, ...input: Input<NoInfer<I>>) => runWith(system, input[0]) as Promise<R>,
         share: port => {
-            checkLive();
-            if (!state.memory.shared) throw new Error("Without cross-origin isolation memory can't be shared, so no thread can join.");
+            if (disposed) return Promise.reject(new Error("The world is disposed."));
+            if (!state.memory.shared) 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 => {
@@ -770,6 +996,8 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
             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.
@@ -805,13 +1033,21 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
                 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;
 };