@adobe/ecs 0.1.0 → 0.2.0

package/src/implementation/world/thread-systems.ts

@@ -1,12 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Entity } from '../../interface/entity/entity.js';
 import type { Commands } from '../../interface/system/commands.js';
 import type { Leaf } from '../../interface/system/leaf.js';
-import type { SystemLookup } from '../../interface/system/access.js';
-import { declarationOf, definitionOf, firstKeyOf, indexOfLookup, isLeaf, itemOfId, kindOf, labelOf, programFinalizers, threadOfDeclaration, watchedBy } from '../../interface/registry/index.js';
+import type { SystemLookupLists } from '../../interface/system/access.js';
+import { declarationOf, definitionOf, firstKeyOf, indexOfLookup, isLeaf, itemOfId, kindOf, labelOf, programFinalizers, threadOfDeclaration, watchedBy, whyUnregistered } from '../../interface/registry/index.js';
 import { layoutOf, objectLayout, viewsOf, type Layout, type Views } from '../../interface/registry/layout.js';
 import type { StringStore } from './strings.js';
 import { stampChanged, writeOf } from './archetype.js';
 import { emptyViews } from './arrays.js';
+import { arrivalsPosition, createDebts, membershipOf, type ArrivalsView } from './arrivals.js';
 import { readCell, writeCell } from './cells.js';
 import {
     beginCommand, createRingWriter, dropCommand, encoderOf, endSegment, localNumbers, objectStart, putComponent, putNull, putSlot, putStart, putValue,
@@ -23,22 +25,25 @@ import type { WorkerError } from './protocol.js';
 import { forEachPassingRange, type Filter } from './ranges.js';
 import { combine, contributed, identityOf, reductionTargetsOf, type ReductionTarget } from './reductions.js';
 import { changedRowOf, emptyRow, rowBinderOf, type RowHost } from './rows.js';
+import { requiredOf } from './required.js';
 import type { Since } from './index-lookups.js';
-import { createBatch, positionalSpawner, type Positional, type SpawnBatch } from './staging.js';
+import { createBatch, noValues, positionalSpawner, type Positional, type SpawnBatch } from './staging.js';
 import { createThreadFinalizers } from './thread-finalizers.js';
+import { createThreadWhere } from './where.js';
 import { createThreadIndex, type ThreadIndex } from './thread-indexes.js';
 import type { EntityViews, ThreadArchetype, ThreadDirectory, ThreadStorage } from './thread-directory.js';
 import { keptSorted } from './index-keys.js';
-import { chunkShift } from './kernel.js';
+import { blockShift, chunkShift } from './kernel.js';
 import {
     doneWord, endWord, headExecuted, headRan, progressWord, snapshotFlagsWord, snapshotLayout, snapshotOffsetWord, snapshotResourceArchetypeWord,
     snapshotResourceRowWord, snapshotRowsWord, snapshotCapacityWord, snapshotted, tailBlockWords, tailChunk, waitingWord,
 } from './tail-blocks.js';
 import { defaultOf, type Key } from './state.js';
+import { isThenable, returnedPromise } from './failures.js';
 import {
     completionCapacityWord, completionMessage, completionOffsetWord, completionSystems, executedFlag, failedFlag, payloadCapacityWord, payloadCount,
     payloadInput, payloadOffsetWord, payloadSequence, payloadSystems, ranFlag, resultEnd, resultFields, resultFlags, resultStart, ringBaseWord, ringCapacityWord,
-    payloadSync, ringCursorWord, ringNeededWord, spilledFlag, systemFields, systemFolds, systemIndex, systemLastRun, systemTail, systemTick, systemTier,
+    payloadSync, ringCursorWord, ringNeededWord, spilledFlag, systemFields, systemFolds, systemIndex, systemLastRun, systemTail, systemTick, systemTier, systemValued, valuedFlag,
     taskDoneWord, taskFailedWord, taskPostedWord,
 } from './thread-tasks.js';
 
@@ -93,11 +98,16 @@ type CommandKey = {
     readonly start: unknown;
     /** Whether it's declared `transfer`, so a staged value whose command drops is released. */
     readonly transfer: boolean;
+    /** Whether it's shared, so only the world's thread spawns and adds it: its value chooses the archetype. */
+    readonly shared: boolean;
 };
 
 /** The system that ran a task's commands, for their checks' errors. */
 type Running = { error: unknown };
 
+/** Whether a task's mirror is current, or why not (`bringCurrent`). */
+type Readiness = "current" | "moved" | "held";
+
 /**
  * Runs the systems the world places on this thread, as tasks it posts in the task block: each task's systems in order,
  * after replaying the mirror through the task's sync, writing each system's commands and spawns as a segment of the
@@ -105,7 +115,7 @@ type Running = { error: unknown };
  */
 export const createThreadSystems = (host: ThreadSystemsHost) => {
     const { mirror, control, directory } = host;
-    const { viewed, rows: rowHost, numbers, refreshEntities, archetypeAt, countOf, resourceRow, tableCount } = directory;
+    const { viewed, rows: rowHost, numbers, refreshEntities, archetypeAt, countOf, arrivals, resourceRow, tableCount } = directory;
     const refreshMemory = (): void => { directory.refresh(); };
     const runners: (ThreadRunner | null | undefined)[] = [];
     const inputs = new Map<number, unknown>();
@@ -128,8 +138,8 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
     const batches = new Map<string, SpawnBatch>();
     const usedBatches: SpawnBatch[] = [];
     /** Spawners by list, and by the numbers of a list's components in its order, for lists made again each call. */
-    const spawners = new WeakMap<readonly unknown[], (values: object) => Entity>();
-    const spawnersByNumbers = new Map<string, (values: object) => Entity>();
+    const spawners = new WeakMap<readonly unknown[], (values?: object) => Entity>();
+    const spawnersByNumbers = new Map<string, (values?: object) => Entity>();
 
     /** A key a command names: checked as the world's commands check it, numbered by the world's number or this thread's. */
     const commandKeyOf = (key: unknown): CommandKey => {
@@ -143,7 +153,7 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
             return known;
         }
         const declaration = declarationOf(key);
-        if (declaration === undefined || kindOf(key) !== "component") throw new Error(kindOf(key) === "resource" ? `"${labelOf(key)}" is a resource, not a component.` : `"${labelOf(key)}" has no registered schema; import the module that registers it.`);
+        if (declaration === undefined || kindOf(key) !== "component") throw new Error(kindOf(key) === "resource" ? `"${labelOf(key)}" is a resource, not a component.` : `"${labelOf(key)}" has no registered schema: ${whyUnregistered(key)}.`);
         if (declaration.derived === true) throw new Error(`"${labelOf(key)}" is derived, so only rules add and remove it.`);
         const layout = layoutOf(declaration.type);
         const own = ownObject(key);
@@ -155,6 +165,7 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
                 : layout.kind === "object" && !own ? `"${labelOf(key)}" lives on thread "${thread ?? "world"}", so a command on another thread gives it only its start or null.` : null,
             start: layout.kind === "constant" ? layout.value : defaultOf(key),
             transfer: declaration.transfer === true,
+            shared: declaration.shared === true,
         };
         commandKeys.set(first, entry);
         commandKeys.set(key, entry);
@@ -185,11 +196,18 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
         return true;
     };
 
+    /** A key a spawn or add gives a value: never a shared component's, whose value chooses an archetype, which only the world's thread does. */
+    const givenKeyOf = (key: unknown): CommandKey => {
+        const entry = commandKeyOf(key);
+        if (entry.shared) throw new Error(`"${labelOf(key)}" is shared: its value chooses an archetype, so only the world's thread spawns and adds it.`);
+        return entry;
+    };
+
     /** Spawns this thread stages of a list's components, into a batch per set, reserving entities in blocks. */
-    const spawnerOf = (list: readonly unknown[]): ((values: object) => Entity) => {
+    const spawnerOf = (list: readonly unknown[]): ((values?: object) => Entity) => {
         const known = spawners.get(list);
         if (known !== undefined) return known;
-        const listed = list.map(commandKeyOf);
+        const listed = list.map(givenKeyOf);
         const ids = listed.map(entry => entry.number);
         const order = ids.join(",");
         const same = spawnersByNumbers.get(order);
@@ -217,7 +235,7 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
         const positional: Positional = positionalSpawner(reserving, reserveFrom, target, ids, listed.map(entry => entry.layout.kind === "object" || entry.layout.kind === "string" ? objectStart : entry.start));
         const keysOfList = list.filter((key): key is Key => typeof key === "symbol");
         const args: unknown[] = new Array<unknown>(keysOfList.length);
-        const spawn = (values: object): Entity => {
+        const spawn = (values: object = noValues): Entity => {
             for (let k = 0; k < keysOfList.length; k++) args[k] = Reflect.get(values, keysOfList[k]);
             if (!usedBatches.includes(target)) usedBatches.push(target);
             return Reflect.apply(positional, undefined, args);
@@ -227,19 +245,49 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
         return spawn;
     };
 
+    /**
+     * Spawns of a list with constants, which no shared component is among: the same function for one list's components
+     * and one constants object, found by its identity here, reading each component's value from the constants or else
+     * from what each spawn gives, and failing its system for one given in both.
+     */
+    const presetSpawners = new WeakMap<(values?: object) => Entity, WeakMap<object, (values?: object) => Entity>>();
+    const presetSpawnerOf = (list: readonly unknown[], preset: object): ((values?: object) => Entity) => {
+        const spawn = spawnerOf(list);
+        let byPreset = presetSpawners.get(spawn);
+        if (byPreset === undefined) presetSpawners.set(spawn, byPreset = new WeakMap());
+        const known = byPreset.get(preset);
+        if (known !== undefined) return known;
+        const keysOfList = list.filter((key): key is Key => typeof key === "symbol");
+        const merged: { [key: string | symbol]: unknown } = {};
+        const spawned = (values: object = noValues): Entity => {
+            for (const key of keysOfList) {
+                const constant: unknown = Reflect.get(preset, key);
+                const given: unknown = Reflect.get(values, key);
+                if (constant !== undefined && given !== undefined) throw new Error(`A spawn gives "${labelOf(key)}" in both its calls: each component's value comes from one.`);
+                merged[key] = constant === undefined ? given : constant;
+            }
+            return spawn(merged);
+        };
+        byPreset.set(preset, spawned);
+        return spawned;
+    };
+
     const empty = {};
     const commands: Commands = {
-        spawn: components => spawnerOf(components),
+        // A second parameter rather than a rest one, which would allocate an array each call.
+        spawn: (components: readonly unknown[], preset?: unknown) => {
+            return typeof preset === "object" && preset !== null ? presetSpawnerOf(components, preset) : spawnerOf(components);
+        },
         despawn: entity => beginCommand(writer, despawnCommand, entity),
         add: (entity: number, components: symbol | readonly symbol[], values?: unknown) => {
             if (typeof components === "symbol") {
-                const key = commandKeyOf(components);
+                const key = givenKeyOf(components);
                 beginCommand(writer, addCommand, entity);
                 if (!putOne(key, entity, values)) dropCommand(writer);
                 return;
             }
             // Every key is checked before anything is written.
-            for (let k = 0; k < components.length; k++) commandKeyOf(components[k]);
+            for (let k = 0; k < components.length; k++) givenKeyOf(components[k]);
             const given = typeof values === "object" && values !== null ? values : empty;
             beginCommand(writer, addCommand, entity);
             let crosses = true;
@@ -281,8 +329,8 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
     };
 
     const runnerHost: RunnerHost = {
-        rows: rowHost, archetypeAt, countOf, tableCount, resourceRow, refreshEntities, commands, mirror,
-        refresh: directory.refresh,
+        rows: rowHost, archetypeAt, countOf, arrivals, tableCount, resourceRow, refreshEntities, commands, mirror,
+        refresh: directory.refresh, replaced: directory.replaced,
         numberOf: directory.numberOf,
         layoutOf: directory.layoutOf,
         strings: directory.strings,
@@ -358,18 +406,25 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
         }));
     };
 
-    /** Brings the mirror up to the last published sync, which runs the finalizers of its stops; false while it can't. */
-    const current = (): boolean => {
+    /**
+     * Brings the mirror up to the last published sync, which runs the finalizers of its stops: `"moved"` when its
+     * rebuild found a sync point applying before or during it, so it can rebuild once that's applied, and `"held"`
+     * while it waits for something else.
+     */
+    const bringCurrent = (): Readiness => {
         const replayed = replay(mirror);
-        if (replayed === "held") return false;
-        return replayed !== "lapped" || rebuild(mirror);
+        if (replayed === "held") return "held";
+        if (replayed !== "lapped") return "current";
+        const rebuilt = rebuild(mirror);
+        return rebuilt === "rebuilt" ? "current" : rebuilt;
     };
+    const current = (): boolean => bringCurrent() === "current";
 
     /** Whether a task can run: its systems known here, its input arrived, and the mirror through its sync. */
-    const ready = (payload: Float64Array, count: number): boolean => {
-        for (let k = 0; k < count; k++) if (runners[payload[payloadSystems + k * systemFields + systemIndex]] === undefined) return false;
-        if (payload[payloadInput] !== 0 && !inputs.has(payload[payloadSequence])) return false;
-        return current();
+    const ready = (payload: Float64Array, count: number): Readiness => {
+        for (let k = 0; k < count; k++) if (runners[payload[payloadSystems + k * systemFields + systemIndex]] === undefined) return "held";
+        if (payload[payloadInput] !== 0 && !inputs.has(payload[payloadSequence])) return "held";
+        return bringCurrent();
     };
 
     /** Views of the payload and completion, kept while the world keeps them where they are. */
@@ -427,15 +482,47 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
         return control;
     };
 
-    /** A task waiting for a sync point to finish applying, to rebuild its mirror, runs once it has. */
+    /**
+     * A task waiting for a sync point to finish applying, to rebuild its mirror, runs once it has. One whose rebuild
+     * found a sync point applied during it runs again after a turn of the event loop: nothing else may wake this thread
+     * before the task is done, and sync points overlapping every rebuild mustn't keep it from its event loop.
+     */
     let structureWaited = false;
-    const retryAfterStructure = (): void => {
-        if (structureWaited || !applying(mirror)) return;
-        structureWaited = true;
-        void waitStructure(mirror).then(() => {
-            structureWaited = false;
-            process();
-        });
+    const retried = (): void => {
+        structureWaited = false;
+        process();
+    };
+    const retryAfterStructure = (moved: boolean): void => {
+        if (structureWaited) return;
+        if (applying(mirror)) {
+            structureWaited = true;
+            void waitStructure(mirror).then(retried);
+        }
+        else if (moved) {
+            structureWaited = true;
+            setTimeout(retried, 0);
+        }
+    };
+
+    /**
+     * Posts a task's message. A value that can't be posted, as one holding a function, fails its system instead, and
+     * the message goes again without values.
+     */
+    const postCompleted = (sequence: number, errors: [number, WorkerError][] | null, spills: [number, Uint8Array][] | null, values: [number, unknown][] | null, transfer: ArrayBuffer[] | null): void => {
+        const extra = stamps.length > 0 ? { stamps: [...stamps] } : {};
+        try {
+            host.post({ protocol: protocolName, kind: "completed", sequence, errors: errors ?? [], spills: spills ?? [], ...values === null ? {} : { values }, ...extra }, transfer ?? []);
+        }
+        catch (error) {
+            if (values === null) throw error;
+            const failed = errors ?? [];
+            for (const [k] of values) {
+                const at = completionSystems + k * resultFields + resultFlags;
+                completion[at] = (completion[at] & ~valuedFlag) | failedFlag;
+                failed.push([k, errorOf(new Error(`Its value can't be posted to the world's thread: ${error instanceof Error ? error.message : String(error)}`))]);
+            }
+            host.post({ protocol: protocolName, kind: "completed", sequence, errors: failed, spills: spills ?? [], ...extra }, transfer ?? []);
+        }
     };
 
     const runTask = (posted: number): void => {
@@ -444,8 +531,9 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
         const count = payload[payloadCount];
         const sequence = payload[payloadSequence];
         pending = sequence;
-        if (!ready(payload, count)) {
-            retryAfterStructure();
+        const readiness = ready(payload, count);
+        if (readiness !== "current") {
+            retryAfterStructure(readiness === "moved");
             return;
         }
         pending = -1;
@@ -456,6 +544,7 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
         let errors: [number, WorkerError][] | null = null;
         let spills: [number, Uint8Array][] | null = null;
         let transfer: ArrayBuffer[] | null = null;
+        let values: [number, unknown][] | null = null;
         let failedTier = -1;
         const folds = completionSystems + count * resultFields;
         stamps.length = 0;
@@ -489,6 +578,11 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
                     flags |= failedFlag;
                     (errors ??= []).push([k, errorOf(outcome.error)]);
                 }
+                else if (outcome.value !== undefined && payload[base + systemValued] !== 0) {
+                    flags |= valuedFlag;
+                    (values ??= []).push([k, outcome.value]);
+                }
+                outcome.value = undefined;
                 completion[result + resultFlags] = flags;
                 continue;
             }
@@ -498,6 +592,11 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
                 if (outcome.executed) flags |= executedFlag;
                 if (outcome.ran) flags |= ranFlag;
                 error = outcome.error ?? running.error;
+                if (error === undefined && outcome.value !== undefined && payload[base + systemValued] !== 0) {
+                    flags |= valuedFlag;
+                    (values ??= []).push([k, outcome.value]);
+                }
+                outcome.value = undefined;
             }
             try {
                 const extent = writeSegment();
@@ -520,9 +619,9 @@ export const createThreadSystems = (host: ThreadSystemsHost) => {
             else if (runner !== null && runner !== undefined && (flags & ranFlag) !== 0) runner.writeFolds(completion, folds + payload[base + systemFolds]);
             completion[result + resultFlags] = flags;
         }
-        const message = errors !== null || spills !== null || stamps.length > 0 || host.numbered() !== numberedBefore || !host.worldWaits;
+        const message = errors !== null || spills !== null || values !== null || stamps.length > 0 || host.numbered() !== numberedBefore || !host.worldWaits;
         completion[completionMessage] = message ? 1 : 0;
-        if (message) host.post({ protocol: protocolName, kind: "completed", sequence, errors: errors ?? [], spills: spills ?? [], ...stamps.length > 0 ? { stamps: [...stamps] } : {} }, transfer ?? []);
+        if (message) postCompleted(sequence, errors, spills, values, transfer);
         Atomics.store(control, taskDoneWord, posted);
         Atomics.notify(control, taskDoneWord);
     };
@@ -565,6 +664,8 @@ export type RunnerHost = {
     readonly rows: RowHost & { tick: number };
     readonly archetypeAt: (id: number) => ThreadArchetype | undefined;
     readonly countOf: (archetype: ThreadArchetype) => number;
+    /** The ring of rows' moves between archetypes, which `where`'s points per archetype read (`arrivals.ts`). */
+    readonly arrivals: () => ArrivalsView | null;
     readonly tableCount: () => number;
     readonly resourceRow: () => { readonly archetype: ThreadArchetype; readonly row: number } | null;
     readonly refreshEntities: () => EntityViews;
@@ -573,14 +674,23 @@ export type RunnerHost = {
     readonly layoutOf: (key: Key) => Layout | undefined;
     /** This thread's objects, null where it fills none. */
     readonly mirror: Mirror | null;
-    /** Views of the memory again, once it grew: its buffer. */
+    /** Views of the memory again, once it grew, and `replaced` moved on if a view may have: its buffer. */
     readonly refresh: () => ArrayBufferLike;
+    /** Moved on by `refresh` once any archetype's view may have changed, which index lookups' rows check (`thread-directory.ts`). */
+    readonly replaced: { readonly count: number };
     /** The records strings' columns name. */
     readonly strings: StringStore;
 };
 
 /** One run's outcome: whether it took its tick, ran its rows, and its error. */
-export type Outcome = { executed: boolean; ran: boolean; error: unknown };
+/** A body's value, or a throw failing its system when it's a promise or another thenable, which nothing awaits. */
+const notThenable = (value: unknown): unknown => {
+    if (isThenable(value)) throw new Error(returnedPromise);
+    return value;
+};
+
+/** How a run of a system went: for one without components, what its body returned too. */
+export type Outcome = { executed: boolean; ran: boolean; error: unknown; value: unknown };
 
 export type ThreadRunner = {
     /** Runs it once, at the tick its host's rows stamp with. */
@@ -606,28 +716,130 @@ type ThreadCell = { storage: ThreadStorage | undefined; row: number };
 export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: ReadonlyMap<string, number> = noRecords): ThreadRunner => {
     const { declaration } = leaf;
     // Method parameters are bivariant, so the runtime can see any leaf's body with erased parameter types.
-    const system: { body(subject: unknown, context?: unknown): void } = leaf;
+    const system: { body(subject: unknown, context?: unknown, input?: unknown): unknown } = leaf;
     const { components: query, resources } = declaration;
     const numberOf = host.numberOf;
-    const required = [...new Set([...query?.read ?? [], ...query?.write ?? [], ...query?.has ?? [], ...query?.added ?? [], ...query?.changed ?? []])].map(numberOf);
+    const required = requiredOf(query).map(numberOf);
     const excluded = (query?.not ?? []).map(numberOf);
     const addedIds = (query?.added ?? []).map(numberOf);
     const changedIds = (query?.changed ?? []).map(numberOf);
     const resourceChanged = (resources?.changed ?? []).map(numberOf);
     const filtered = addedIds.length + changedIds.length + resourceChanged.length > 0;
-    const bindRow = rowBinderOf<ThreadArchetype>(host.rows, numberOf, query?.read ?? [], query?.write ?? []);
+    const bindRow = rowBinderOf<ThreadArchetype>(host.rows, numberOf, query?.read ?? [], query?.write ?? [], query?.optional);
     const matches: number[] = [];
     let checked = 0;
+    /** Its `where`, run here as on the world's thread (`where.ts`); null without one. */
+    const where = query?.where === undefined ? null : createThreadWhere({ archetypeAt: host.archetypeAt, numberOf, resourceRow: host.resourceRow, tick: () => host.rows.tick - 1 }, query.where, query.whereReads ?? []);
+    /** With `where` and change filters, each match's own last run, as on the world's thread. */
+    const pointed = where !== null && filtered;
+    const points: number[] = [];
+    /** By archetype id, its match, or -1. */
+    const matchOf: number[] = [];
+    /** Its `lastRun` as of its run here: a new match's point, and a non-match's, whose rows it never saw. */
+    let latest = 0;
+    /** What archetypes owe for rows moved in from others, as on the world's thread. */
+    const debts = pointed ? createDebts(points, matchOf, arrivalsPosition(host.arrivals())) : null;
+    const oldestPoint = (): number => {
+        let oldest = latest;
+        for (let m = 0; m < matches.length; m++) if (points[m] < oldest) oldest = points[m];
+        return oldest;
+    };
+    /** By match, its archetype's generation as matched: reused for other values (`reclaim.ts`), it's matched anew. */
+    const generations: number[] = [];
+    /**
+     * The world's count of archetypes reclaimed and reused as it last looked, which it follows as it changes; null before
+     * its first look, which sees every archetype as it is.
+     */
+    let followed: number | null = null;
+    const isMatch = (archetype: ThreadArchetype): boolean => {
+        const has = (id: number): boolean => archetype.components.includes(id);
+        return !archetype.resource && !archetype.reclaimed && required.every(has) && !excluded.some(has);
+    };
+    const addMatch = (id: number, archetype: ThreadArchetype): void => {
+        const m = matches.length;
+        points[m] = latest;
+        generations[m] = archetype.generation;
+        matchOf[id] = m;
+        matches.push(id);
+    };
+    const moveMatch = (from: number, to: number): void => {
+        const id = matches[from];
+        matches[to] = id;
+        points[to] = points[from];
+        generations[to] = generations[from];
+        matchOf[id] = to;
+        where?.move(from, to);
+    };
+    const swapMatches = (a: number, b: number): void => {
+        if (a === b) return;
+        const first = matches[a];
+        const point = points[a];
+        const generation = generations[a];
+        matches[a] = matches[b];
+        points[a] = points[b];
+        generations[a] = generations[b];
+        matchOf[matches[a]] = a;
+        matches[b] = first;
+        points[b] = point;
+        generations[b] = generation;
+        matchOf[first] = b;
+        where?.swapped(a, b);
+    };
+    /** As on the world's thread: one evaluated by `where` stays among those evaluated. */
+    const removeMatch = (m: number): void => {
+        matchOf[matches[m]] = -1;
+        let hole = m;
+        if (where !== null && m < where.evaluated) {
+            const edge = where.evaluated - 1;
+            if (edge !== hole) moveMatch(edge, hole);
+            hole = edge;
+            where.forgetLast();
+        }
+        const last = matches.length - 1;
+        if (hole !== last) moveMatch(last, hole);
+        matches.length = points.length = generations.length = last;
+    };
+    /**
+     * Once archetypes were reclaimed or reused: each match reclaimed leaves, each reused is matched anew, and each it
+     * has seen and doesn't match is matched once reused, reading every record it has seen. Arrivals are read first, as
+     * on the world's thread.
+     */
+    const followMembership = (): void => {
+        debts?.read(host.arrivals(), host.rows.tick, host.tableCount(), latest, oldestPoint);
+        for (let m = matches.length - 1; m >= 0; m--) {
+            const archetype = host.archetypeAt(matches[m]);
+            if (archetype === undefined || archetype.reclaimed) removeMatch(m);
+            else if (archetype.generation !== generations[m]) {
+                points[m] = latest;
+                generations[m] = archetype.generation;
+                if (where !== null && m < where.evaluated) {
+                    swapMatches(m, where.evaluated - 1);
+                    where.forgetLast();
+                }
+            }
+        }
+        for (let id = 0; id < checked; id++) {
+            if ((matchOf[id] ?? -1) >= 0) continue;
+            const archetype = host.archetypeAt(id);
+            if (archetype !== undefined && isMatch(archetype)) addMatch(id, archetype);
+        }
+    };
     const refreshMatches = (): void => {
+        const membership = membershipOf(host.arrivals());
+        if (followed === null) followed = membership;
+        else if (membership !== followed) {
+            followed = membership;
+            followMembership();
+        }
         for (const count = host.tableCount(); checked < count; checked++) {
             const archetype = host.archetypeAt(checked);
             if (archetype === undefined) break;
-            const has = (id: number): boolean => archetype.components.includes(id);
-            if (!archetype.resource && !(archetype.meta && required.length === 0) && required.every(has) && !excluded.some(has)) matches.push(checked);
+            matchOf[checked] = -1;
+            if (isMatch(archetype)) addMatch(checked, archetype);
         }
     };
     const ownInput = inputFor(leaf);
-    const targets: readonly ReductionTarget[] = reductionTargetsOf(host.layoutOf, declaration);
+    const targets: readonly ReductionTarget[] = reductionTargetsOf(host.layoutOf, leaf.name, declaration);
     const reduced = targets.map(target => new Float64Array(target.leaves.length));
 
     // The context: resources, lookups, reductions, input and commands, each under its own key when declared.
@@ -677,10 +889,10 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
             if (index === undefined || record === undefined) found = entityLookupOf(host, declared, lookupSince);
             else {
                 const reads = declared.read ?? [];
-                const threadIndex = createThreadIndex(host.rows, host.archetypeAt, {
+                const threadIndex = createThreadIndex(host.rows, host.archetypeAt, host.replaced, {
                     layouts: index.declaration.key.map(key => {
                         const layout = host.layoutOf(key);
-                        if (layout === undefined) throw new Error(`"${labelOf(key)}" has no registered schema; import the module that registers it.`);
+                        if (layout === undefined) throw new Error(`"${labelOf(key)}" has no registered schema: ${whyUnregistered(key)}.`);
                         return layout;
                     }),
                     sorted: keptSorted(index.declaration),
@@ -711,14 +923,14 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
         });
         Object.defineProperty(value, "reduce", { value: reducers, enumerable: true });
     }
-    if (declaration.input !== undefined) value.input = undefined;
     // A tail is terminal, so its context has no commands.
-    const tailValue: { input?: unknown } = own();
+    const tailValue: object = own();
     for (const name of Object.getOwnPropertyNames(value)) {
         const descriptor = Object.getOwnPropertyDescriptor(value, name);
-        if (descriptor !== undefined && name !== "input") Object.defineProperty(tailValue, name, descriptor);
+        if (descriptor !== undefined) Object.defineProperty(tailValue, name, descriptor);
     }
-    if (declaration.input !== undefined) tailValue.input = undefined;
+    /** The current run's input, which the body takes after its context; kept until the next run, as its context is. */
+    let runInput: unknown;
     Object.defineProperty(value, "commands", { value: host.commands, enumerable: true });
 
     /** Resolves resource cells for a run: they move only at sync points. */
@@ -763,11 +975,11 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
         const filters: Filter[] = [];
         for (const id of addedIds) {
             const storage = archetype.storageById[id];
-            if (storage !== undefined) filters.push({ ticks: storage.added, chunks: storage.chunkAdded });
+            if (storage !== undefined) filters.push({ ticks: storage.added, chunks: storage.chunkAdded, blocks: storage.blockAdded });
         }
         for (const id of changedIds) {
             const storage = archetype.storageById[id];
-            if (storage !== undefined) filters.push({ ticks: storage.changed, chunks: storage.chunkChanged });
+            if (storage !== undefined) filters.push({ ticks: storage.changed, chunks: storage.chunkChanged, blocks: storage.blockChanged });
         }
         filterCache.set(archetype.id, { archetype, filters });
         return filters;
@@ -776,28 +988,29 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
     const runBody = (archetype: ThreadArchetype, count: number, since: number): void => {
         const row = bindRow(archetype);
         const subject = row.value;
+        const input = runInput;
         const filters = filtersOf(archetype);
         if (since < 0 || filters.length === 0) {
             for (let index = 0; index < count; index++) {
                 row.index = index;
-                system.body(subject, value);
+                system.body(subject, value, input);
             }
             return;
         }
         forEachPassingRange(filters, since, 0, count, (start, end) => {
             for (let index = start; index < end; index++) {
                 row.index = index;
-                system.body(subject, value);
+                system.body(subject, value, input);
             }
         });
     };
 
-    const outcome: Outcome = { executed: false, ran: false, error: undefined };
+    const outcome: Outcome = { executed: false, ran: false, error: undefined, value: undefined };
     /** Set once its system is removed on this thread: no row runs from then on. */
     let halted = false;
     const run = (lastRun: number, input: unknown): Outcome => {
         outcome.executed = outcome.ran = false;
-        outcome.error = undefined;
+        outcome.error = outcome.value = undefined;
         lookupSince.value = lastRun;
         try {
             // A system whose conditions don't hold is skipped, successfully, and keeps its `lastRun`.
@@ -808,23 +1021,41 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
             const since = !filtered || resourcesChanged ? -1 : lastRun;
             bind();
             if (threadIndexes.length !== 0) {
+                // Settles the count after `ready()` or `current()` may have rebuilt the mirror, since `runTask` settles before them.
                 const buffer = host.refresh();
                 for (let k = 0; k < threadIndexes.length; k++) threadIndexes[k].refresh(buffer);
             }
-            if (declaration.input !== undefined) value.input = ownInput(input);
+            runInput = ownInput(input);
             if (query === undefined) {
                 outcome.ran = since < 0;
-                if (outcome.ran) system.body(value);
+                if (outcome.ran) outcome.value = notThenable(system.body(value, runInput));
                 return outcome;
             }
-            if (since >= 0 && addedIds.length + changedIds.length === 0) return outcome;
+            if (since >= 0 && addedIds.length + changedIds.length === 0 && !pointed) return outcome;
             outcome.ran = true;
+            latest = lastRun;
             refreshMatches();
-            for (let m = 0; m < matches.length; m++) {
-                const archetype = host.archetypeAt(matches[m]);
+            debts?.read(host.arrivals(), host.rows.tick, host.tableCount(), latest, oldestPoint);
+            if (where !== null) where.refresh(matches);
+            const list = where === null ? matches : where.passing;
+            const listed = where === null ? matches.length : where.count;
+            for (let k = 0; k < listed; k++) {
+                const archetype = host.archetypeAt(list[k]);
                 if (archetype === undefined) continue;
+                let from = since;
+                if (pointed && where !== null) {
+                    const m = where.indices[k];
+                    if (since >= 0) {
+                        // Rows moved in since its point count as changed since their old archetype's.
+                        const point = debts?.sinceOf(list[k], points[m]) ?? points[m];
+                        from = resourceChanged.length > 0 && resourcesChangedSince(point) ? -1 : point;
+                    }
+                    points[m] = host.rows.tick;
+                    debts?.settle(list[k]);
+                    if (from >= 0 && addedIds.length + changedIds.length === 0) continue;
+                }
                 const count = host.countOf(archetype);
-                if (count > 0) runBody(archetype, count, since);
+                if (count > 0) runBody(archetype, count, from);
             }
         }
         catch (error) {
@@ -837,6 +1068,8 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
     // thread's, which it reads from its mirror at the snapshot's rows.
     const readKeys = query?.read ?? [];
     const writeKeys = query?.write ?? [];
+    /** Its optional components, which rows from a snapshot have only where their archetype does. */
+    const optionalNumbers = (query?.optional ?? []).map(numberOf);
     const linearReads: { readonly number: number; readonly layout: Columned }[] = [];
     const constantReads: { readonly number: number; readonly layout: Layout }[] = [];
     for (const key of readKeys) {
@@ -845,6 +1078,8 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
         if (layout?.kind === "linear" || layout?.kind === "string") linearReads.push({ number: numberOf(key), layout });
         else if (layout?.kind === "constant") constantReads.push({ number: numberOf(key), layout });
     }
+    /** The shared components it reads, whose values a snapshot's rows take from their archetypes. */
+    const sharedReads = constantReads.flatMap(({ number, layout }) => layout.kind === "constant" && layout.shared === true ? [number] : []);
     const objectKeys = [...new Set([...readKeys, ...writeKeys])].filter(key => host.layoutOf(key)?.kind === "object").map(numberOf);
     const writtenObjects = new Set(writeKeys.map(numberOf));
     const snapshotResources = resourceKeys.flatMap((key, k) => {
@@ -866,22 +1101,25 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
     const runRows = (archetype: ThreadArchetype, start: number, end: number, since: number): void => {
         const row = bindRow(archetype);
         const subject = row.value;
+        const input = runInput;
         const filters = filtersOf(archetype);
         if (since < 0 || filters.length === 0) {
             for (let index = start; index < end && !halted; index++) {
                 row.index = index;
-                system.body(subject, tailValue);
+                system.body(subject, tailValue, input);
             }
             return;
         }
         forEachPassingRange(filters, since, start, end, (first, last) => {
             for (let index = first; index < last && !halted; index++) {
                 row.index = index;
-                system.body(subject, tailValue);
+                system.body(subject, tailValue, input);
             }
         });
     };
 
+    /** By match as of the head, with `where`: the tick its rows pass after, -2 for one `where` skips. */
+    const tailSinces: number[] = [];
     /** Runs positions `from` to `to` where their rows are, over the archetypes as of the head. */
     const runPositions = (from: number, to: number, since: number): void => {
         let base = 0;
@@ -890,7 +1128,8 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
             const start = Math.max(from - 1 - base, 0);
             const end = Math.min(to - 1 - base, count);
             const archetype = tailArchetypes[m];
-            if (end > start && archetype !== undefined) runRows(archetype, start, end, since);
+            const passing = where === null ? since : tailSinces[m];
+            if (end > start && archetype !== undefined && passing !== -2) runRows(archetype, start, end, passing);
             base += count;
             if (base >= to - 1) return;
         }
@@ -953,10 +1192,10 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
             if ((flags & headExecuted) === 0) return;
             outcome.executed = true;
             outcome.ran = (flags & headRan) !== 0;
-            if (declaration.input !== undefined) tailValue.input = ownInput(input);
+            runInput = ownInput(input);
             if (!outcome.ran) return;
             if (query === undefined) {
-                system.body(tailValue);
+                outcome.value = notThenable(system.body(tailValue, runInput));
                 writeBackResources(ownResources, resourceArchetype, resourceRow, tick, at, stamps);
                 return;
             }
@@ -969,7 +1208,8 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
         linearReads.forEach(({ number, layout: linear }, k) => {
             storageById[number] = localStorage(number, linear, viewsOf(buffer, offset + placed.columns[k], rows * linear.stride), [], 0, host.strings);
         });
-        for (const { number, layout: constant } of constantReads) storageById[number] = localStorage(number, constant, emptyViews, [], 0, host.strings);
+        // A shared component's value is each row's archetype's, bound a run of one archetype's rows at a time.
+        for (const { number, layout: constant } of constantReads) if (constant.kind !== "constant" || constant.shared !== true) storageById[number] = localStorage(number, constant, emptyViews, [], 0, host.strings);
         const objects: { readonly number: number; readonly storage: ThreadStorage }[] = [];
         for (const number of objectKeys) {
             const values = new Array<unknown>(rows);
@@ -987,12 +1227,56 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
         }
         let first = 0;
         while (first < rows && positions[first] < position) first++;
-        const row = bindRow({ id: -1, entities, storageById, record: -1, version: -1, mirrored: null, components: [], resource: false, meta: false });
-        const subject = row.value;
+        // With `where`, rows of archetypes it skips don't run: the copy holds every matched row then (`headOf`).
+        const skipped = where === null ? null : new Set(matches.filter((_, m) => tailSinces[m] === -2));
+        const copied = (storages: readonly (ThreadStorage | undefined)[]): ThreadArchetype =>
+            ({ id: -1, entities, storageById: storages, record: -1, version: -1, mirrored: null, components: [], resource: false, reclaimed: false, generation: 0 });
+        const ownedInput = runInput;
         try {
-            for (let index = first; index < rows && !halted; index++) {
-                row.index = index;
-                system.body(subject, tailValue);
+            if (optionalNumbers.length === 0 && sharedReads.length === 0) {
+                const row = bindRow(copied(storageById));
+                const subject = row.value;
+                for (let index = first; index < rows && !halted; index++) {
+                    if (skipped !== null && skipped.has(archetypeIds[index])) continue;
+                    row.index = index;
+                    system.body(subject, tailValue, ownedInput);
+                }
+            }
+            else {
+                // Rows of archetypes that lack optional components run in a row without them, a run of one archetype's rows
+                // at a time, and every archetype with the same ones shares its copy of the snapshot's columns; with
+                // shared components, each archetype has its own, holding its values.
+                const byPattern = new Map<number, ThreadArchetype>();
+                for (let index = first; index < rows && !halted;) {
+                    const id = archetypeIds[index];
+                    let end = index + 1;
+                    while (end < rows && archetypeIds[end] === id) end++;
+                    if (skipped !== null && skipped.has(id)) {
+                        index = end;
+                        continue;
+                    }
+                    const components = host.archetypeAt(id)?.components ?? [];
+                    let pattern = 0;
+                    for (let k = 0; k < optionalNumbers.length; k++) if (components.includes(optionalNumbers[k])) pattern |= 1 << k;
+                    const key = sharedReads.length === 0 ? pattern : -1 - id;
+                    let archetype = byPattern.get(key);
+                    if (archetype === undefined) {
+                        const storages: (ThreadStorage | undefined)[] = [...storageById];
+                        optionalNumbers.forEach((number, k) => { if ((pattern & (1 << k)) === 0) storages[number] = undefined; });
+                        const viewed = sharedReads.length === 0 ? undefined : host.archetypeAt(id);
+                        for (const number of sharedReads) {
+                            const layout = viewed?.storageById[number]?.layout;
+                            storages[number] = layout === undefined ? undefined : localStorage(number, layout, emptyViews, [], 0, host.strings);
+                        }
+                        byPattern.set(key, archetype = copied(storages));
+                    }
+                    const row = bindRow(archetype);
+                    const subject = row.value;
+                    for (; index < end && !halted; index++) {
+                        row.index = index;
+                        system.body(subject, tailValue, ownedInput);
+                    }
+                }
             }
         }
         finally {
@@ -1031,7 +1315,7 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
      */
     const runTail = (lastRun: number, input: unknown, control: Int32Array, sync: number, at: number, stamps: number[], first?: number, outcomeAt?: number): Outcome => {
         outcome.executed = outcome.ran = false;
-        outcome.error = undefined;
+        outcome.error = outcome.value = undefined;
         lookupSince.value = lastRun;
         let claimed = first ?? Atomics.add(control, progressWord, tailChunk);
         const end = Atomics.load(control, endWord);
@@ -1051,21 +1335,41 @@ export const createThreadRunner = (host: RunnerHost, leaf: Leaf, records: Readon
             const resourcesChanged = resourceChanged.length > 0 && resourcesChangedSince(lastRun);
             const since = !filtered || resourcesChanged ? -1 : lastRun;
             bind();
-            if (declaration.input !== undefined) tailValue.input = ownInput(input);
+            runInput = ownInput(input);
             if (query === undefined) {
                 outcome.ran = since < 0;
-                if (outcome.ran) system.body(tailValue);
+                if (outcome.ran) outcome.value = notThenable(system.body(tailValue, runInput));
                 return outcome;
             }
-            if (since >= 0 && addedIds.length + changedIds.length === 0) return outcome;
+            if (since >= 0 && addedIds.length + changedIds.length === 0 && !pointed) return outcome;
             outcome.ran = true;
+            latest = lastRun;
             refreshMatches();
+            debts?.read(host.arrivals(), host.rows.tick, host.tableCount(), latest, oldestPoint);
             tailArchetypes.length = tailCounts.length = 0;
             for (let m = 0; m < matches.length; m++) {
                 const archetype = host.archetypeAt(matches[m]);
                 tailArchetypes.push(archetype);
                 tailCounts.push(archetype === undefined ? 0 : host.countOf(archetype));
             }
+            if (where !== null) {
+                where.refresh(matches);
+                for (let m = 0; m < matches.length; m++) tailSinces[m] = -2;
+                for (let k = 0; k < where.count; k++) {
+                    const m = where.indices[k];
+                    const archetype = tailArchetypes[m];
+                    let from = since;
+                    if (pointed && since >= 0 && archetype !== undefined) {
+                        const point = debts?.sinceOf(matches[m], points[m]) ?? points[m];
+                        from = resourceChanged.length > 0 && resourcesChangedSince(point) ? -1 : point;
+                    }
+                    if (pointed) {
+                        points[m] = host.rows.tick;
+                        debts?.settle(matches[m]);
+                    }
+                    tailSinces[m] = pointed && from >= 0 && addedIds.length + changedIds.length === 0 ? -2 : from;
+                }
+            }
             let from = 1;
             for (;;) {
                 const to = Math.min(claimed + tailChunk, end);
@@ -1105,16 +1409,25 @@ type Columned = Extract<Layout, { readonly stride: number }>;
 /** A storage over a snapshot's column, or of values only this thread holds, with ticks of its own for `ticked` rows. */
 const localStorage = (component: number, layout: Layout, views: Views, values: unknown[], ticked: number, strings: StringStore): ThreadStorage => {
     const chunks = ticked === 0 ? 0 : (ticked >> chunkShift) + 1;
+    const blocks = ticked === 0 ? 0 : (ticked >> blockShift) + 1;
     return {
         component, layout, views, strings: layout.kind === "string" ? strings : null, values, ...writeOf(layout), tags: noTags, ticked: ticked > 0,
         added: ticked === 0 ? noTicks : new Float64Array(ticked), changed: ticked === 0 ? noTicks : new Float64Array(ticked),
         chunkAdded: chunks === 0 ? noTicks : new Float64Array(chunks), chunkChanged: chunks === 0 ? noTicks : new Float64Array(chunks),
+        blockAdded: blocks === 0 ? noTicks : new Float64Array(blocks), blockChanged: blocks === 0 ? noTicks : new Float64Array(blocks),
     };
 };
 
+/** What a lookup reads and requires: its reads but its optional components, which an entity it finds may lack. */
+const requiredReads = (host: RunnerHost, lookup: SystemLookupLists): readonly number[] => {
+    const optional = "optional" in lookup ? lookup.optional ?? [] : [];
+    return (lookup.read ?? []).filter(key => !optional.includes(key)).map(host.numberOf);
+};
+
 /** A lookup returning `read` values keyed by component, from this thread's views. */
-const lookupOf = (host: RunnerHost, lookup: SystemLookup) => {
+const lookupOf = (host: RunnerHost, lookup: SystemLookupLists) => {
     const read = (lookup.read ?? []).map(host.numberOf);
+    const required = requiredReads(host, lookup);
     const has = ("has" in lookup ? lookup.has ?? [] : []).map(host.numberOf);
     const not = ("not" in lookup ? lookup.not ?? [] : []).map(host.numberOf);
     const keys = lookup.read ?? [];
@@ -1125,7 +1438,7 @@ const lookupOf = (host: RunnerHost, lookup: SystemLookup) => {
         const archetype = host.archetypeAt(table.archetype[index]);
         if (archetype === undefined || archetype.resource) return null;
         const { components } = archetype;
-        for (const id of read) if (!components.includes(id)) return null;
+        for (const id of required) if (!components.includes(id)) return null;
         for (const id of has) if (!components.includes(id)) return null;
         for (const id of not) if (components.includes(id)) return null;
         const row = table.row[index];
@@ -1139,7 +1452,7 @@ const lookupOf = (host: RunnerHost, lookup: SystemLookup) => {
 };
 
 /** A lookup reading nothing, from this thread's views: the shared empty row for every entity it finds. */
-const emptyLookupOf = (host: RunnerHost, lookup: SystemLookup) => {
+const emptyLookupOf = (host: RunnerHost, lookup: SystemLookupLists) => {
     const has = ("has" in lookup ? lookup.has ?? [] : []).map(host.numberOf);
     const not = ("not" in lookup ? lookup.not ?? [] : []).map(host.numberOf);
     return (entity: Entity): object | null => {
@@ -1160,8 +1473,9 @@ const emptyLookupOf = (host: RunnerHost, lookup: SystemLookup) => {
  * a component `watched` names may have changed in it after `since`. A GPU kernel's column stamps reach this thread as
  * row ticks; a component keeping no ticks counts as changed.
  */
-const changedLookupOf = (host: RunnerHost, lookup: SystemLookup, watched: readonly Key[], since: Since) => {
+const changedLookupOf = (host: RunnerHost, lookup: SystemLookupLists, watched: readonly Key[], since: Since) => {
     const read = (lookup.read ?? []).map(host.numberOf);
+    const required = requiredReads(host, lookup);
     const has = ("has" in lookup ? lookup.has ?? [] : []).map(host.numberOf);
     const not = ("not" in lookup ? lookup.not ?? [] : []).map(host.numberOf);
     const ids = watched.map(host.numberOf);
@@ -1174,7 +1488,7 @@ const changedLookupOf = (host: RunnerHost, lookup: SystemLookup, watched: readon
         const archetype = host.archetypeAt(table.archetype[index]);
         if (archetype === undefined || archetype.resource) return null;
         const { components, storageById } = archetype;
-        for (const id of read) if (!components.includes(id)) return null;
+        for (const id of required) if (!components.includes(id)) return null;
         for (const id of has) if (!components.includes(id)) return null;
         for (const id of not) if (components.includes(id)) return null;
         const row = table.row[index];
@@ -1193,7 +1507,7 @@ const changedLookupOf = (host: RunnerHost, lookup: SystemLookup, watched: readon
 };
 
 /** The lookup by entity a declaration chooses, once: with `changed`, reading nothing, or reading values. */
-const entityLookupOf = (host: RunnerHost, lookup: SystemLookup, since: Since) => {
+const entityLookupOf = (host: RunnerHost, lookup: SystemLookupLists, since: Since) => {
     const watched = "index" in lookup ? undefined : lookup.changed;
     if (watched !== undefined) return changedLookupOf(host, lookup, watched, since);
     return (lookup.read ?? []).length === 0 ? emptyLookupOf(host, lookup) : lookupOf(host, lookup);