@adobe/ecs 0.0.0-stage → 0.1.0

package/dist/implementation/world/thread-systems.js

@@ -0,0 +1,1169 @@
+import { declarationOf, definitionOf, firstKeyOf, indexOfLookup, isLeaf, itemOfId, kindOf, labelOf, programFinalizers, threadOfDeclaration, watchedBy } from '../../interface/registry/index.js';
+import { layoutOf, objectLayout, viewsOf } from '../../interface/registry/layout.js';
+import { stampChanged, writeOf } from './archetype.js';
+import { emptyViews } from './arrays.js';
+import { readCell, writeCell } from './cells.js';
+import { beginCommand, createRingWriter, dropCommand, encoderOf, endSegment, localNumbers, objectStart, putComponent, putNull, putSlot, putStart, putValue, startSegment, } from './command-ring.js';
+import { addCommand, despawnCommand, removeCommand } from './buffer.js';
+import { createBlock, endBlock, locate, reserveFrom } from './entities.js';
+import { inputFor } from './input.js';
+import { protocolName } from './joining.js';
+import { ownTag } from './move-log.js';
+import { ranExecuted, ranSkipped } from './joined-observer.js';
+import { applying, rebuild, replay, stage, waitStructure } from './mirror.js';
+import { forEachPassingRange } from './ranges.js';
+import { combine, contributed, identityOf, reductionTargetsOf } from './reductions.js';
+import { changedRowOf, emptyRow, rowBinderOf } from './rows.js';
+import { createBatch, positionalSpawner } from './staging.js';
+import { createThreadFinalizers } from './thread-finalizers.js';
+import { createThreadIndex } from './thread-indexes.js';
+import { keptSorted } from './index-keys.js';
+import { 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 } from './state.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, taskDoneWord, taskFailedWord, taskPostedWord, } from './thread-tasks.js';
+// A joined thread's systems (threads.md, "Systems on other threads"): runners over the world's archetypes as the layout
+// directory describes them, struct columns and resources in shared memory, this thread's objects in its mirror
+// (`mirror.ts`), with commands and spawns written into its command ring, run as tasks the world posts.
+/** For tests: tails on this thread that read every row from a snapshot, being late, and that switched to one at a chunk. */
+export const tailSnapshots = { late: 0, switched: 0 };
+const errorOf = (error) => error instanceof Error ? { name: error.name, message: error.message, stack: error.stack } : { name: "Error", message: String(error) };
+const noTicks = new Float64Array(0);
+const noTags = new Uint32Array(0);
+const noBatches = [];
+/**
+ * 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
+ * command ring, its flags and folds into the completion, then storing the task done and waking the world.
+ */
+export const createThreadSystems = (host) => {
+    const { mirror, control, directory } = host;
+    const { viewed, rows: rowHost, numbers, refreshEntities, archetypeAt, countOf, resourceRow, tableCount } = directory;
+    const refreshMemory = () => { directory.refresh(); };
+    const runners = [];
+    const inputs = new Map();
+    /** The task waiting for what it needs: its systems' setups, its input, or this thread's objects; -1 for none. */
+    let pending = -1;
+    const writer = createRingWriter();
+    let block = null;
+    const unused = [];
+    /** Whether a component's values are objects of a thread this one fills. */
+    const ownObject = (key) => {
+        const declaration = declarationOf(key);
+        const thread = declaration === undefined ? null : threadOfDeclaration(declaration);
+        return thread !== null && host.claims.has(thread) && layoutOf(declaration?.type).kind === "object";
+    };
+    const commandKeys = new Map();
+    const commandKeysByNumber = new Map();
+    /** By sorted numbers of a list's components, the batch its spawns stage into, and by list, its spawner. */
+    const batches = new Map();
+    const usedBatches = [];
+    /** 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();
+    const spawnersByNumbers = new Map();
+    /** 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) => {
+        if (typeof key !== "symbol")
+            throw new Error(Array.isArray(key) ? "A command names a list of components where one component's symbol goes." : `"${labelOf(key)}" isn't a component: a component's key is a symbol.`);
+        const direct = commandKeys.get(key);
+        if (direct !== undefined)
+            return direct;
+        const first = firstKeyOf(key);
+        const known = commandKeys.get(first);
+        if (known !== undefined) {
+            commandKeys.set(key, known);
+            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.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);
+        const thread = threadOfDeclaration(declaration);
+        const number = numbers.get(first) ?? localNumbers + host.keyNumber(key);
+        const entry = {
+            number, layout, encoder: encoderOf(layout), own,
+            elsewhere: layout.kind === "string" ? `"${labelOf(key)}" is a string, which only the world's thread writes, so a command on another thread gives it only its start.`
+                : 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,
+        };
+        commandKeys.set(first, entry);
+        commandKeys.set(key, entry);
+        commandKeysByNumber.set(number, entry);
+        return entry;
+    };
+    /** The system whose commands are being written, so a value that can't cross fails it. */
+    const running = { error: undefined };
+    /** The tick of the system running, which staged values settle by. */
+    let sync = 0;
+    /** Writes one value of an add: a struct's bytes; an object of this thread staged; another's start or null, else dropped. */
+    const putOne = (key, entity, value) => {
+        const { layout, number } = key;
+        if (layout.kind !== "object" && layout.kind !== "string") {
+            if (value === undefined)
+                putStart(writer, number);
+            else
+                putValue(writer, number, key.encoder, value);
+            return true;
+        }
+        if (value === undefined || value === key.start)
+            putStart(writer, number);
+        else if (value === null)
+            putNull(writer, number);
+        else if (key.own)
+            putSlot(writer, number, stage(mirror, entity, number, value, sync, key.transfer));
+        else {
+            running.error ??= new Error(key.elsewhere ?? "");
+            return false;
+        }
+        return true;
+    };
+    /** Spawns this thread stages of a list's components, into a batch per set, reserving entities in blocks. */
+    const spawnerOf = (list) => {
+        const known = spawners.get(list);
+        if (known !== undefined)
+            return known;
+        const listed = list.map(commandKeyOf);
+        const ids = listed.map(entry => entry.number);
+        const order = ids.join(",");
+        const same = spawnersByNumbers.get(order);
+        if (same !== undefined) {
+            spawners.set(list, same);
+            return same;
+        }
+        if (new Set(ids).size !== ids.length)
+            throw new Error("A spawn names a component twice.");
+        const sorted = [...ids].sort((a, b) => a - b);
+        const signature = sorted.join(",");
+        let batch = batches.get(signature);
+        if (batch === undefined) {
+            const byNumber = [];
+            listed.forEach(entry => { byNumber[entry.number] = entry.layout; });
+            batch = createBatch(byNumber, ids);
+            for (const column of batch.columns) {
+                const entry = listed.find(candidate => candidate.number === column.id);
+                if (entry?.elsewhere !== null)
+                    column.remote = entry?.elsewhere ?? null;
+            }
+            batches.set(signature, batch);
+        }
+        const target = batch;
+        const reserving = block ??= createBlock(refreshEntities());
+        // An object's or a string's start is the world's to resolve.
+        const 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) => typeof key === "symbol");
+        const args = new Array(keysOfList.length);
+        const spawn = (values) => {
+            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);
+        };
+        spawners.set(list, spawn);
+        spawnersByNumbers.set(order, spawn);
+        return spawn;
+    };
+    const empty = {};
+    const commands = {
+        spawn: components => spawnerOf(components),
+        despawn: entity => beginCommand(writer, despawnCommand, entity),
+        add: (entity, components, values) => {
+            if (typeof components === "symbol") {
+                const key = commandKeyOf(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]);
+            const given = typeof values === "object" && values !== null ? values : empty;
+            beginCommand(writer, addCommand, entity);
+            let crosses = true;
+            for (let k = 0; k < components.length; k++)
+                if (!putOne(commandKeyOf(components[k]), entity, Reflect.get(given, components[k])))
+                    crosses = false;
+            if (!crosses)
+                dropCommand(writer);
+        },
+        remove: (entity, components) => {
+            if (typeof components === "symbol") {
+                const { number } = commandKeyOf(components);
+                beginCommand(writer, removeCommand, entity);
+                putComponent(writer, number);
+                return;
+            }
+            for (let k = 0; k < components.length; k++)
+                commandKeyOf(components[k]);
+            beginCommand(writer, removeCommand, entity);
+            for (let k = 0; k < components.length; k++)
+                putComponent(writer, commandKeyOf(components[k]).number);
+        },
+    };
+    /** Stages a value a spawn gives this thread's object, as its segment is written. */
+    const slots = (component, entity, value) => {
+        if (value === undefined || value === null || value === objectStart)
+            return -1;
+        const key = commandKeysByNumber.get(component);
+        return key?.own === true ? stage(mirror, entity, component, value, sync, key.transfer) : -1;
+    };
+    /** Writes the running system's segment: its commands, its spawns, and the reservations it left unused. */
+    const writeSegment = () => {
+        unused.length = 0;
+        if (block !== null)
+            endBlock(block, unused);
+        const cursor = Atomics.load(control, ringCursorWord);
+        if (writer.count === 0 && usedBatches.length === 0 && unused.length === 0)
+            return { start: cursor, end: cursor, spill: null, transfer: null };
+        const extent = endSegment(writer, viewed.views, Atomics.load(control, ringBaseWord) >>> 0, Atomics.load(control, ringCapacityWord), cursor, usedBatches.length === 0 ? noBatches : usedBatches, unused, slots);
+        usedBatches.length = 0;
+        Atomics.store(control, ringCursorWord, extent.end);
+        Atomics.store(control, ringNeededWord, Atomics.load(control, ringNeededWord) + extent.end - extent.start + (extent.spill?.length ?? 0));
+        return extent;
+    };
+    const runnerHost = {
+        rows: rowHost, archetypeAt, countOf, tableCount, resourceRow, refreshEntities, commands, mirror,
+        refresh: directory.refresh,
+        numberOf: directory.numberOf,
+        layoutOf: directory.layoutOf,
+        strings: directory.strings,
+    };
+    /** Takes the world's numbers for the keys of systems or finalizers it places here. */
+    const name = directory.name;
+    /** By index: the byte offset of the word the world sets once it removed the system there, which no task runs from then on. */
+    const removedWords = [];
+    /** By index: the block of its tail's last task, whose view goes with it. */
+    const tailBlocks = [];
+    /** Systems the world removed, dropped once the thread finished `sequence`, the last task posted before. */
+    const unplacing = [];
+    /** Records the systems the world places here; one this thread never imported fails each task that names it. */
+    const setup = (systems) => {
+        name(systems);
+        for (const { index, id, removed, indexes } of systems) {
+            const item = itemOfId(id);
+            const definition = item === undefined ? undefined : definitionOf(item);
+            runners[index] = definition === undefined || !isLeaf(definition) ? null : createThreadRunner(runnerHost, definition, new Map(indexes));
+            removedWords[index] = removed;
+        }
+    };
+    /** Drops what's held for removed systems no task runs again, and tells the world, so it may place their indexes again. */
+    const dropUnplaced = () => {
+        if (unplacing.length === 0)
+            return;
+        const done = Atomics.load(control, taskDoneWord);
+        const dropped = [];
+        for (let k = unplacing.length - 1; k >= 0; k--) {
+            const { indexes, sequence } = unplacing[k];
+            if (sequence > done)
+                continue;
+            unplacing.splice(k, 1);
+            for (const index of indexes) {
+                runners[index] = undefined;
+                removedWords[index] = undefined;
+                const block = tailBlocks[index];
+                if (block !== undefined)
+                    tailControls.delete(block);
+                tailBlocks[index] = undefined;
+                dropped.push(index);
+            }
+        }
+        if (dropped.length > 0)
+            host.post({ protocol: protocolName, kind: "unplaced", indexes: dropped });
+    };
+    /** The world removed systems here: dropped once the last task posted before them is done. */
+    const unplace = (indexes, sequence) => {
+        unplacing.push({ indexes, sequence });
+        dropUnplaced();
+    };
+    const finalizers = createThreadFinalizers({
+        mirror,
+        refresh: directory.refresh,
+        rows: rowHost,
+        numberOf: runnerHost.numberOf,
+        layoutOf: runnerHost.layoutOf,
+        archetypeAt, countOf, tableCount, resourceRow,
+        strings: directory.strings,
+        failed: errors => host.post({ protocol: protocolName, kind: "finalized", errors }),
+    });
+    mirror.finalize = finalizers.through;
+    /** Records the finalizers the world places here; one this thread never imported fails each group of its stops. */
+    const setupFinalizers = (setups) => {
+        name(setups);
+        finalizers.setup(setups.map(({ index, id }) => {
+            const item = itemOfId(id);
+            const leaf = programFinalizers().find(finalizer => finalizer === item);
+            return { index, leaf: leaf?.kind === "finalizer" ? leaf : null };
+        }));
+    };
+    /** Brings the mirror up to the last published sync, which runs the finalizers of its stops; false while it can't. */
+    const current = () => {
+        const replayed = replay(mirror);
+        if (replayed === "held")
+            return false;
+        return replayed !== "lapped" || rebuild(mirror);
+    };
+    /** Whether a task can run: its systems known here, its input arrived, and the mirror through its sync. */
+    const ready = (payload, count) => {
+        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();
+    };
+    /** Views of the payload and completion, kept while the world keeps them where they are. */
+    let payload = new Float64Array(0);
+    let completion = new Float64Array(0);
+    const viewTask = () => {
+        const payloadOffset = Atomics.load(control, payloadOffsetWord) >>> 0;
+        const completionOffset = Atomics.load(control, completionOffsetWord) >>> 0;
+        const { buffer } = viewed;
+        if (payload.buffer !== buffer || payload.byteOffset !== payloadOffset || payload.length !== Atomics.load(control, payloadCapacityWord) / 8) {
+            payload = new Float64Array(buffer, payloadOffset, Atomics.load(control, payloadCapacityWord) / 8);
+        }
+        if (completion.buffer !== buffer || completion.byteOffset !== completionOffset || completion.length !== Atomics.load(control, completionCapacityWord) / 8) {
+            completion = new Float64Array(buffer, completionOffset, Atomics.load(control, completionCapacityWord) / 8);
+        }
+    };
+    /**
+     * Fails every system of the posted task, when this thread can't run it: its memory is short of the world's, or its
+     * views of it failed. It writes nothing the views would reach, as they may be stale: the failed word says the task
+     * failed whole, and the message, of the sequence the world posted, why.
+     */
+    const failTask = (posted, error) => {
+        pending = -1;
+        host.post({ protocol: protocolName, kind: "completed", sequence: posted, errors: [[0, errorOf(error)]], spills: [] });
+        Atomics.store(control, taskFailedWord, posted);
+        Atomics.store(control, taskDoneWord, posted);
+        Atomics.notify(control, taskDoneWord);
+    };
+    /**
+     * Runs the posted task, if any and it can run; else it waits for what it needs, and `process` runs it then. Returns
+     * whether it finished one.
+     */
+    const process = () => {
+        const posted = Atomics.load(control, taskPostedWord);
+        if (posted === Atomics.load(control, taskDoneWord))
+            return false;
+        try {
+            runTask(posted);
+        }
+        catch (error) {
+            failTask(posted, error);
+        }
+        dropUnplaced();
+        return Atomics.load(control, taskDoneWord) === posted;
+    };
+    /** The objects tails of the task wrote from their snapshots, for the world to stamp. */
+    const stamps = [];
+    /** Views of tails' blocks by offset, kept while the memory's buffer is the same. */
+    const tailControls = new Map();
+    const tailControl = (offset) => {
+        let control = tailControls.get(offset);
+        if (control === undefined || control.buffer !== viewed.buffer)
+            tailControls.set(offset, control = new Int32Array(viewed.buffer, offset, tailBlockWords));
+        return control;
+    };
+    /** A task waiting for a sync point to finish applying, to rebuild its mirror, runs once it has. */
+    let structureWaited = false;
+    const retryAfterStructure = () => {
+        if (structureWaited || !applying(mirror))
+            return;
+        structureWaited = true;
+        void waitStructure(mirror).then(() => {
+            structureWaited = false;
+            process();
+        });
+    };
+    const runTask = (posted) => {
+        refreshMemory();
+        viewTask();
+        const count = payload[payloadCount];
+        const sequence = payload[payloadSequence];
+        pending = sequence;
+        if (!ready(payload, count)) {
+            retryAfterStructure();
+            return;
+        }
+        pending = -1;
+        refreshEntities();
+        const input = inputs.get(sequence);
+        inputs.delete(sequence);
+        const numberedBefore = host.numbered();
+        let errors = null;
+        let spills = null;
+        let transfer = null;
+        let failedTier = -1;
+        const folds = completionSystems + count * resultFields;
+        stamps.length = 0;
+        for (let k = 0; k < count; k++) {
+            const base = payloadSystems + k * systemFields;
+            const result = completionSystems + k * resultFields;
+            const tier = payload[base + systemTier];
+            completion[result + resultFlags] = 0;
+            completion[result + resultStart] = completion[result + resultEnd] = 0;
+            // A failed tier stops the task after it: later tiers are skipped.
+            if (failedTier >= 0 && tier > failedTier)
+                continue;
+            const index = payload[base + systemIndex];
+            // Removed since the task was posted: it runs no more, and gives back nothing.
+            const removed = removedWords[index];
+            if (removed !== undefined && Atomics.load(viewed.words, removed >>> 2) !== 0)
+                continue;
+            const runner = runners[index];
+            const tick = payload[base + systemTick];
+            rowHost.tick = sync = tick;
+            running.error = undefined;
+            startSegment(writer, { tick, archetype: 0, start: k });
+            let flags = 0;
+            let error = undefined;
+            const tail = payload[base + systemTail];
+            if (tail !== 0 && runner !== null && runner !== undefined) {
+                tailBlocks[index] = tail;
+                // A tail writes no commands, so no segment.
+                const outcome = runner.runTail(payload[base + systemLastRun], input, tailControl(tail), payload[payloadSync], k, stamps);
+                if (outcome.executed)
+                    flags |= executedFlag;
+                if (outcome.ran)
+                    flags |= ranFlag;
+                if (outcome.error !== undefined) {
+                    flags |= failedFlag;
+                    (errors ??= []).push([k, errorOf(outcome.error)]);
+                }
+                completion[result + resultFlags] = flags;
+                continue;
+            }
+            if (runner === null || runner === undefined)
+                error = new Error("A system the world placed on this thread isn't one this thread imported.");
+            else {
+                const outcome = runner.run(payload[base + systemLastRun], input);
+                if (outcome.executed)
+                    flags |= executedFlag;
+                if (outcome.ran)
+                    flags |= ranFlag;
+                error = outcome.error ?? running.error;
+            }
+            try {
+                const extent = writeSegment();
+                completion[result + resultStart] = extent.start;
+                completion[result + resultEnd] = extent.end;
+                if (extent.spill !== null && extent.transfer !== null) {
+                    flags |= spilledFlag;
+                    (spills ??= []).push([k, extent.spill]);
+                    (transfer ??= []).push(extent.transfer);
+                }
+            }
+            catch (thrown) {
+                error ??= thrown;
+            }
+            if (error !== undefined) {
+                flags |= failedFlag;
+                (errors ??= []).push([k, errorOf(error)]);
+                failedTier = tier;
+            }
+            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;
+        completion[completionMessage] = message ? 1 : 0;
+        if (message)
+            host.post({ protocol: protocolName, kind: "completed", sequence, errors: errors ?? [], spills: spills ?? [], ...stamps.length > 0 ? { stamps: [...stamps] } : {} }, transfer ?? []);
+        Atomics.store(control, taskDoneWord, posted);
+        Atomics.notify(control, taskDoneWord);
+    };
+    return {
+        setup,
+        setupFinalizers,
+        /**
+         * Runs the finalizers of stops published since this thread last replayed, if any, as it replays them; and
+         * releases staged `transfer` values whose commands dropped.
+         */
+        finalize: () => {
+            if (finalizers.pending() || mirror.stagedTransfers > 0)
+                current();
+        },
+        /** Once the world is disposed: finalizers run for the stops published, then for every row they match. */
+        disposed: () => {
+            try {
+                if (current())
+                    finalizers.all();
+            }
+            catch (error) {
+                host.post({ protocol: protocolName, kind: "finalized", errors: [[-1, errorOf(error)]] });
+            }
+        },
+        /** A task's input, posted by message. */
+        input: (sequence, input) => {
+            inputs.set(sequence, input);
+            if (pending === sequence)
+                process();
+        },
+        process,
+        /** Whether a task waits for what it needs. */
+        waiting: () => pending >= 0,
+        unplace,
+        /** For tests of what a thread holds: how many systems the world placed here that it keeps. */
+        systems: () => runners.filter(runner => runner !== undefined).length,
+    };
+};
+const noRecords = new Map();
+/** Runs one system here, as the world's runner runs a main-thread system (`runner.ts`). */
+export const createThreadRunner = (host, leaf, records = noRecords) => {
+    const { declaration } = leaf;
+    // Method parameters are bivariant, so the runtime can see any leaf's body with erased parameter types.
+    const system = 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 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(host.rows, numberOf, query?.read ?? [], query?.write ?? []);
+    const matches = [];
+    let checked = 0;
+    const refreshMatches = () => {
+        for (const count = host.tableCount(); checked < count; checked++) {
+            const archetype = host.archetypeAt(checked);
+            if (archetype === undefined)
+                break;
+            const has = (id) => archetype.components.includes(id);
+            if (!archetype.resource && !(archetype.meta && required.length === 0) && required.every(has) && !excluded.some(has))
+                matches.push(checked);
+        }
+    };
+    const ownInput = inputFor(leaf);
+    const targets = reductionTargetsOf(host.layoutOf, 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.
+    const own = () => Object.create({});
+    const value = own();
+    const writes = new Set(resources?.write);
+    const resourceKeys = [...new Set([...resources?.read ?? [], ...resources?.is ?? [], ...writes])];
+    const cells = resourceKeys.map(() => ({ storage: undefined, row: 0 }));
+    const resourceNumbers = resourceKeys.map(numberOf);
+    const cellFor = (k) => {
+        const cell = cells[k];
+        if (cell.storage === undefined)
+            throw new Error(`Resource "${labelOf(resourceKeys[k])}" isn't in this world.`);
+        return cell;
+    };
+    if (resourceKeys.length > 0) {
+        const values = own();
+        resourceKeys.forEach((key, k) => {
+            Object.defineProperty(values, key, {
+                get: () => {
+                    const { storage, row } = cellFor(k);
+                    return storage === undefined ? undefined : readCell(storage, row);
+                },
+                set: writes.has(key) ? (next) => {
+                    const { storage, row } = cellFor(k);
+                    if (storage === undefined)
+                        return;
+                    writeCell(storage, row, next);
+                    if (storage.tags.length !== 0)
+                        storage.tags[row] = ownTag;
+                    stampChanged(storage, row, host.rows.tick);
+                } : undefined,
+                enumerable: true,
+            });
+        });
+        Object.defineProperty(value, "resources", { value: values, enumerable: true });
+    }
+    const names = Object.keys(declaration.lookup ?? {});
+    /** Its `lastRun` while it runs, which its lookups by entity compare with. */
+    const lookupSince = { value: 0 };
+    /** Its lookups through indexes, whose views each run points at the index's arrays. */
+    const threadIndexes = [];
+    if (names.length > 0) {
+        const lookups = own();
+        for (const name of names) {
+            const declared = declaration.lookup?.[name] ?? {};
+            const index = indexOfLookup(declared);
+            const record = records.get(name);
+            let found;
+            if (index === undefined || record === undefined)
+                found = entityLookupOf(host, declared, lookupSince);
+            else {
+                const reads = declared.read ?? [];
+                const threadIndex = createThreadIndex(host.rows, host.archetypeAt, {
+                    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.`);
+                        return layout;
+                    }),
+                    sorted: keptSorted(index.declaration),
+                    unique: index.declaration.unique === true,
+                    reads,
+                    readIds: reads.map(numberOf),
+                    watched: watchedBy(declared).length,
+                    record,
+                });
+                threadIndexes.push(threadIndex);
+                found = threadIndex.lookup;
+            }
+            Object.defineProperty(lookups, name, { value: found, enumerable: true });
+        }
+        Object.defineProperty(value, "lookup", { value: lookups, enumerable: true });
+    }
+    if (targets.length > 0) {
+        const reducers = own();
+        targets.forEach((target, t) => {
+            const accumulators = reduced[t];
+            const { operator, leaves } = target;
+            Object.defineProperty(reducers, target.key, {
+                value: (contribution) => {
+                    for (let i = 0; i < leaves.length; i++)
+                        accumulators[i] = combine(operator, accumulators[i] ?? NaN, contributed(contribution, leaves[i]?.path ?? []));
+                },
+                enumerable: true,
+            });
+        });
+        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 = 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 (declaration.input !== undefined)
+        tailValue.input = undefined;
+    Object.defineProperty(value, "commands", { value: host.commands, enumerable: true });
+    /** Resolves resource cells for a run: they move only at sync points. */
+    const bind = () => {
+        const found = resourceKeys.length === 0 ? null : host.resourceRow();
+        for (let k = 0; k < resourceKeys.length; k++) {
+            cells[k].storage = found?.archetype.storageById[resourceNumbers[k]];
+            cells[k].row = found?.row ?? 0;
+        }
+        for (let t = 0; t < targets.length; t++)
+            reduced[t].fill(identityOf(targets[t].operator));
+    };
+    const conditionIs = (resources?.is ?? []).map(numberOf);
+    const conditionNot = (resources?.not ?? []).map(numberOf);
+    const conditions = [...conditionIs, ...conditionNot];
+    const holding = (found, id) => {
+        const storage = found?.archetype.storageById[id];
+        if (storage === undefined || found === null)
+            return false;
+        const held = readCell(storage, found.row);
+        return held !== null && held !== false;
+    };
+    const holds = () => {
+        if (conditions.length === 0)
+            return true;
+        const found = host.resourceRow();
+        return conditionIs.every(id => holding(found, id)) && !conditionNot.some(id => holding(found, id));
+    };
+    const resourcesChangedSince = (since) => {
+        const found = host.resourceRow();
+        if (found === null)
+            return false;
+        for (const id of resourceChanged) {
+            const storage = found.archetype.storageById[id];
+            if (storage !== undefined && storage.changed[found.row] > since)
+                return true;
+        }
+        return false;
+    };
+    /** By archetype, its change filters, as of its view. */
+    const filterCache = new Map();
+    const filtersOf = (archetype) => {
+        const cached = filterCache.get(archetype.id);
+        if (cached !== undefined && cached.archetype === archetype)
+            return cached.filters;
+        const filters = [];
+        for (const id of addedIds) {
+            const storage = archetype.storageById[id];
+            if (storage !== undefined)
+                filters.push({ ticks: storage.added, chunks: storage.chunkAdded });
+        }
+        for (const id of changedIds) {
+            const storage = archetype.storageById[id];
+            if (storage !== undefined)
+                filters.push({ ticks: storage.changed, chunks: storage.chunkChanged });
+        }
+        filterCache.set(archetype.id, { archetype, filters });
+        return filters;
+    };
+    const runBody = (archetype, count, since) => {
+        const row = bindRow(archetype);
+        const subject = row.value;
+        const filters = filtersOf(archetype);
+        if (since < 0 || filters.length === 0) {
+            for (let index = 0; index < count; index++) {
+                row.index = index;
+                system.body(subject, value);
+            }
+            return;
+        }
+        forEachPassingRange(filters, since, 0, count, (start, end) => {
+            for (let index = start; index < end; index++) {
+                row.index = index;
+                system.body(subject, value);
+            }
+        });
+    };
+    const outcome = { executed: false, ran: false, error: undefined };
+    /** Set once its system is removed on this thread: no row runs from then on. */
+    let halted = false;
+    const run = (lastRun, input) => {
+        outcome.executed = outcome.ran = false;
+        outcome.error = undefined;
+        lookupSince.value = lastRun;
+        try {
+            // A system whose conditions don't hold is skipped, successfully, and keeps its `lastRun`.
+            if (!holds())
+                return outcome;
+            outcome.executed = true;
+            const resourcesChanged = resourceChanged.length > 0 && resourcesChangedSince(lastRun);
+            /** -1 passes every row. */
+            const since = !filtered || resourcesChanged ? -1 : lastRun;
+            bind();
+            if (threadIndexes.length !== 0) {
+                const buffer = host.refresh();
+                for (let k = 0; k < threadIndexes.length; k++)
+                    threadIndexes[k].refresh(buffer);
+            }
+            if (declaration.input !== undefined)
+                value.input = ownInput(input);
+            if (query === undefined) {
+                outcome.ran = since < 0;
+                if (outcome.ran)
+                    system.body(value);
+                return outcome;
+            }
+            if (since >= 0 && addedIds.length + changedIds.length === 0)
+                return outcome;
+            outcome.ran = true;
+            refreshMatches();
+            for (let m = 0; m < matches.length; m++) {
+                const archetype = host.archetypeAt(matches[m]);
+                if (archetype === undefined)
+                    continue;
+                const count = host.countOf(archetype);
+                if (count > 0)
+                    runBody(archetype, count, since);
+            }
+        }
+        catch (error) {
+            outcome.error = error;
+        }
+        return outcome;
+    };
+    // As a tail: its linear reads and resources, which a snapshot holds, and the objects it reads and writes, this
+    // thread's, which it reads from its mirror at the snapshot's rows.
+    const readKeys = query?.read ?? [];
+    const writeKeys = query?.write ?? [];
+    const linearReads = [];
+    const constantReads = [];
+    for (const key of readKeys) {
+        const layout = host.layoutOf(key);
+        // A string's snapshot column holds handles of records the world copied for it.
+        if (layout?.kind === "linear" || layout?.kind === "string")
+            linearReads.push({ number: numberOf(key), layout });
+        else if (layout?.kind === "constant")
+            constantReads.push({ number: numberOf(key), layout });
+    }
+    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) => {
+        const layout = host.layoutOf(key);
+        return (layout?.kind === "linear" || layout?.kind === "string") && !writes.has(key) ? [{ k, layout }] : [];
+    });
+    const strides = linearReads.map(({ layout }) => layout.stride);
+    const resourceStrides = snapshotResources.map(({ layout }) => layout.stride);
+    /** Matched archetypes' views and counts as of the tail's head. */
+    const tailArchetypes = [];
+    const tailCounts = [];
+    /** Where the tail finished reading through; the world waits for it once it took a snapshot. */
+    const finish = (control, through) => {
+        Atomics.store(control, doneWord, through);
+        if (Atomics.load(control, waitingWord) !== 0)
+            Atomics.notify(control, doneWord);
+    };
+    const runRows = (archetype, start, end, since) => {
+        const row = bindRow(archetype);
+        const subject = row.value;
+        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);
+            }
+            return;
+        }
+        forEachPassingRange(filters, since, start, end, (first, last) => {
+            for (let index = first; index < last && !halted; index++) {
+                row.index = index;
+                system.body(subject, tailValue);
+            }
+        });
+    };
+    /** Runs positions `from` to `to` where their rows are, over the archetypes as of the head. */
+    const runPositions = (from, to, since) => {
+        let base = 0;
+        for (let m = 0; m < tailCounts.length; m++) {
+            const count = tailCounts[m];
+            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);
+            base += count;
+            if (base >= to - 1)
+                return;
+        }
+    };
+    /** Where each entity's row is in the mirror, for a mirror rebuilt past the tail's sync. */
+    const locations = (component) => {
+        const found = new Map();
+        for (const mirrored of host.mirror?.archetypes ?? []) {
+            const column = mirrored?.byComponent[component];
+            if (mirrored === null || mirrored === undefined || column === undefined)
+                continue;
+            for (let row = 0; row < mirrored.count; row++)
+                found.set(mirrored.entities[row], { values: column.values, row });
+        }
+        return found;
+    };
+    /**
+     * Runs the rest from the snapshot, from `position` on: its head too when `head`. Reads only the snapshot and this
+     * thread's mirror, never the world's storages, which may have moved since; objects it writes go back to the mirror
+     * after, and are stamped by the world.
+     */
+    const runSnapshot = (control, position, head, sync, input, at, stamps) => {
+        const buffer = host.refresh();
+        const offset = Atomics.load(control, snapshotOffsetWord) >>> 0;
+        const rows = Atomics.load(control, snapshotRowsWord);
+        const flags = Atomics.load(control, snapshotFlagsWord);
+        const placed = snapshotLayout(Atomics.load(control, snapshotCapacityWord), strides, resourceStrides);
+        if (position === 0)
+            tailSnapshots.late++;
+        else
+            tailSnapshots.switched++;
+        const { mirror } = host;
+        const tick = host.rows.tick;
+        const bounded = mirror === null || mirror.through === (sync >>> 0);
+        const resourceArchetype = Atomics.load(control, snapshotResourceArchetypeWord);
+        const resourceRow = Atomics.load(control, snapshotResourceRowWord);
+        // Resources: structs from the snapshot, this thread's objects from its mirror's resource row.
+        const ownResources = [];
+        resourceKeys.forEach((key, k) => {
+            const layout = host.layoutOf(key);
+            const component = resourceNumbers[k];
+            if (layout === undefined)
+                return;
+            const copied = snapshotResources.findIndex(entry => entry.k === k);
+            if (copied >= 0) {
+                const stride = resourceStrides[copied];
+                cells[k].storage = localStorage(component, layout, viewsOf(buffer, offset + placed.resources[copied], stride), [], 0, host.strings);
+                cells[k].row = 0;
+                return;
+            }
+            if (layout.kind === "object") {
+                const value = mirror?.archetypes[resourceArchetype]?.byComponent[component]?.values[resourceRow];
+                const storage = localStorage(component, layout, emptyViews, [value], 1, host.strings);
+                cells[k].storage = storage;
+                cells[k].row = 0;
+                ownResources.push({ k, component, storage });
+                return;
+            }
+            cells[k].storage = localStorage(component, layout, emptyViews, [], 0, host.strings);
+            cells[k].row = 0;
+        });
+        if (head) {
+            if ((flags & headExecuted) === 0)
+                return;
+            outcome.executed = true;
+            outcome.ran = (flags & headRan) !== 0;
+            if (declaration.input !== undefined)
+                tailValue.input = ownInput(input);
+            if (!outcome.ran)
+                return;
+            if (query === undefined) {
+                system.body(tailValue);
+                writeBackResources(ownResources, resourceArchetype, resourceRow, tick, at, stamps);
+                return;
+            }
+        }
+        const positions = new Uint32Array(buffer, offset + placed.positions, rows);
+        const archetypeIds = new Uint32Array(buffer, offset + placed.archetypes, rows);
+        const rowsOf = new Uint32Array(buffer, offset + placed.rows, rows);
+        const entities = new Float64Array(buffer, offset + placed.entities, rows);
+        const storageById = [];
+        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);
+        const objects = [];
+        for (const number of objectKeys) {
+            const values = new Array(rows);
+            const byEntity = bounded ? null : locations(number);
+            for (let i = 0; i < rows; i++) {
+                if (byEntity === null)
+                    values[i] = mirror?.archetypes[archetypeIds[i]]?.byComponent[number]?.values[rowsOf[i]];
+                else {
+                    const location = byEntity.get(entities[i]);
+                    values[i] = location?.values[location.row];
+                }
+            }
+            const storage = localStorage(number, objectLayout, emptyViews, values, writtenObjects.has(number) ? rows : 0, host.strings);
+            storageById[number] = storage;
+            if (writtenObjects.has(number))
+                objects.push({ number, storage });
+        }
+        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;
+        try {
+            for (let index = first; index < rows && !halted; index++) {
+                row.index = index;
+                system.body(subject, tailValue);
+            }
+        }
+        finally {
+            // What it wrote goes back to the mirror, where its rows are now.
+            for (const { number, storage } of objects) {
+                const byEntity = bounded ? null : locations(number);
+                for (let i = first; i < rows; i++) {
+                    if (storage.changed[i] !== tick)
+                        continue;
+                    if (byEntity === null) {
+                        const column = mirror?.archetypes[archetypeIds[i]]?.byComponent[number];
+                        if (column !== undefined)
+                            column.values[rowsOf[i]] = storage.values[i];
+                    }
+                    else {
+                        const location = byEntity.get(entities[i]);
+                        if (location !== undefined)
+                            location.values[location.row] = storage.values[i];
+                    }
+                    stamps.push(at, entities[i], number);
+                }
+            }
+            writeBackResources(ownResources, resourceArchetype, resourceRow, tick, at, stamps);
+        }
+    };
+    const writeBackResources = (resources, archetype, row, tick, at, stamps) => {
+        for (const { component, storage } of resources) {
+            if (storage.changed[0] !== tick)
+                continue;
+            const column = host.mirror?.archetypes[archetype]?.byComponent[component];
+            if (column !== undefined)
+                column.values[row] = storage.values[0];
+            stamps.push(at, -1, component);
+        }
+    };
+    /**
+     * `first` is its first claim when the caller made it; with `outcomeAt`, the word of `control` whether it ran, and
+     * took its tick, is stored at before its done word.
+     */
+    const runTail = (lastRun, input, control, sync, at, stamps, first, outcomeAt) => {
+        outcome.executed = outcome.ran = false;
+        outcome.error = undefined;
+        lookupSince.value = lastRun;
+        let claimed = first ?? Atomics.add(control, progressWord, tailChunk);
+        const end = Atomics.load(control, endWord);
+        try {
+            // An observer system on this thread looks up through indexes as the world wrote them into its records.
+            if (threadIndexes.length !== 0) {
+                const buffer = host.refresh();
+                for (let k = 0; k < threadIndexes.length; k++)
+                    threadIndexes[k].refresh(buffer);
+            }
+            if (claimed >= snapshotted) {
+                runSnapshot(control, 0, true, sync, input, at, stamps);
+                return outcome;
+            }
+            // The head, within the first claim: conditions, resources and the archetypes as of the tail's sync.
+            if (!holds())
+                return outcome;
+            outcome.executed = true;
+            const resourcesChanged = resourceChanged.length > 0 && resourcesChangedSince(lastRun);
+            const since = !filtered || resourcesChanged ? -1 : lastRun;
+            bind();
+            if (declaration.input !== undefined)
+                tailValue.input = ownInput(input);
+            if (query === undefined) {
+                outcome.ran = since < 0;
+                if (outcome.ran)
+                    system.body(tailValue);
+                return outcome;
+            }
+            if (since >= 0 && addedIds.length + changedIds.length === 0)
+                return outcome;
+            outcome.ran = true;
+            refreshMatches();
+            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));
+            }
+            let from = 1;
+            for (;;) {
+                const to = Math.min(claimed + tailChunk, end);
+                if (from < to)
+                    runPositions(from, to, since);
+                if (to >= end)
+                    return outcome;
+                finish(control, to);
+                const next = to;
+                claimed = Atomics.add(control, progressWord, tailChunk);
+                if (claimed >= snapshotted) {
+                    runSnapshot(control, next, false, sync, input, at, stamps);
+                    return outcome;
+                }
+                from = claimed;
+            }
+        }
+        catch (error) {
+            outcome.error = error;
+            return outcome;
+        }
+        finally {
+            if (outcomeAt !== undefined)
+                Atomics.store(control, outcomeAt, outcome.executed ? ranExecuted : ranSkipped);
+            finish(control, end);
+        }
+    };
+    const writeFolds = (completion, at) => {
+        let offset = at;
+        for (const accumulators of reduced)
+            for (let i = 0; i < accumulators.length; i++)
+                completion[offset++] = accumulators[i];
+    };
+    return { run, runTail, writeFolds, halt: () => { halted = true; } };
+};
+/** 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, layout, views, values, ticked, strings) => {
+    const chunks = ticked === 0 ? 0 : (ticked >> chunkShift) + 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),
+    };
+};
+/** A lookup returning `read` values keyed by component, from this thread's views. */
+const lookupOf = (host, lookup) => {
+    const read = (lookup.read ?? []).map(host.numberOf);
+    const has = ("has" in lookup ? lookup.has ?? [] : []).map(host.numberOf);
+    const not = ("not" in lookup ? lookup.not ?? [] : []).map(host.numberOf);
+    const keys = lookup.read ?? [];
+    return (entity) => {
+        const table = host.refreshEntities();
+        const index = locate(table, entity);
+        if (index < 0)
+            return null;
+        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 has)
+            if (!components.includes(id))
+                return null;
+        for (const id of not)
+            if (components.includes(id))
+                return null;
+        const row = table.row[index];
+        const values = {};
+        for (let i = 0; i < keys.length; i++) {
+            const storage = archetype.storageById[read[i]];
+            values[keys[i]] = storage === undefined ? undefined : readCell(storage, row);
+        }
+        return values;
+    };
+};
+/** A lookup reading nothing, from this thread's views: the shared empty row for every entity it finds. */
+const emptyLookupOf = (host, lookup) => {
+    const has = ("has" in lookup ? lookup.has ?? [] : []).map(host.numberOf);
+    const not = ("not" in lookup ? lookup.not ?? [] : []).map(host.numberOf);
+    return (entity) => {
+        const table = host.refreshEntities();
+        const index = locate(table, entity);
+        if (index < 0)
+            return null;
+        const archetype = host.archetypeAt(table.archetype[index]);
+        if (archetype === undefined || archetype.resource)
+            return null;
+        const { components } = archetype;
+        for (const id of has)
+            if (!components.includes(id))
+                return null;
+        for (const id of not)
+            if (components.includes(id))
+                return null;
+        return emptyRow;
+    };
+};
+/**
+ * A lookup with `changed`, from this thread's views: one row reused, its `read` values keyed by component, and whether
+ * 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, lookup, watched, since) => {
+    const read = (lookup.read ?? []).map(host.numberOf);
+    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);
+    const keys = lookup.read ?? [];
+    const found = changedRowOf(keys);
+    return (entity) => {
+        const table = host.refreshEntities();
+        const index = locate(table, entity);
+        if (index < 0)
+            return null;
+        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 has)
+            if (!components.includes(id))
+                return null;
+        for (const id of not)
+            if (components.includes(id))
+                return null;
+        const row = table.row[index];
+        for (let i = 0; i < keys.length; i++) {
+            const storage = storageById[read[i]];
+            found[keys[i]] = storage === undefined ? undefined : readCell(storage, row);
+        }
+        let changed = since.value < 0;
+        for (let i = 0; i < ids.length && !changed; i++) {
+            const storage = storageById[ids[i]];
+            changed = storage === undefined || !storage.ticked || storage.changed[row] > since.value;
+        }
+        found.changed = changed;
+        return found;
+    };
+};
+/** The lookup by entity a declaration chooses, once: with `changed`, reading nothing, or reading values. */
+const entityLookupOf = (host, lookup, 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);
+};
+//# sourceMappingURL=thread-systems.js.map