@adobe/ecs 0.0.0-stage → 0.2.0

package/dist/implementation/world/layout-directory.js

@@ -0,0 +1,273 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { allocateArray, freeArray, growArray } from './arrays.js';
+/**
+ * Where everything in the shared memory is, for other threads: a header at offset 0 that never moves, a table of
+ * archetype record offsets by archetype id, and a record per archetype. Every word is a `Uint32`, since memory reaches
+ * 4 GiB. The world's thread keeps its JS fields as the source of truth and writes records only at flushes, each
+ * record's version last, with `Atomics.store`; a reader checks a record's version before using what it cached.
+ *
+ * Header words: the memory's length in pages (`memory.ts`), the table's offset and length, the structure epoch, then
+ * the entity-table record: its `cursor` offset, which never moves, `free` offset and capacity, `archetype`, `row` and
+ * `generation` offsets and their capacity, and its version; then the resource entity's index plus one, 0 for none; the
+ * structure epoch's waiters; how many flushes replaced an existing archetype's arrays; and the offset of the ring of
+ * rows' moves (`arrivals.ts`), 0 before one. The table's length is `cursor[2]`.
+ *
+ * The structure epoch is odd from the start of each sync point that applies anything until its directory writes at the
+ * end, and even otherwise. A thread reading entity locations outside a task reads while it's even and checks it again
+ * after, retrying on a change, and waits on it while it's odd, counted in the waiters word first; the world notifies
+ * waiting readers when it turns even.
+ */
+export const tableOffsetWord = 1;
+export const tableLengthWord = 2;
+export const structureWord = 3;
+export const entitiesWord = 4;
+export const cursorField = 0;
+export const freeField = 1;
+export const freeCapacityField = 2;
+export const archetypeField = 3;
+export const rowField = 4;
+export const generationField = 5;
+export const capacityField = 6;
+export const entitiesVersionField = 7;
+export const resourceEntityWord = 12;
+/** Readers waiting on the structure epoch, so the world notifies only when one is. */
+export const structureWaitersWord = 13;
+/**
+ * Flushes that wrote an existing archetype's record again, its arrays replaced, so a joined thread checks this word
+ * once a run rather than each record's version for every row it reads.
+ */
+export const replacedWord = 14;
+/**
+ * An archetype record: its capacity, `entities` offset, storage count, version, flags, row count and generation, then
+ * per storage its component number, flags, column, `added`, `changed`, `chunkAdded` and `chunkChanged` offsets, chunk count, and
+ * `blockAdded` and `blockChanged` offsets, of `chunks << (chunkShift - blockShift)` blocks. Offsets a storage doesn't
+ * have are 0. A record is allocated once, since an archetype's storages are fixed, and never moves. Its count is
+ * written at flushes while a joined thread may read it, for archetypes whose count changed.
+ */
+export const recordCapacity = 0;
+export const recordEntities = 1;
+export const recordStorages = 2;
+export const recordVersion = 3;
+export const recordFlags = 4;
+export const recordCount = 5;
+/** How many times it was reused for other shared values (`reclaim.ts`), which a joined thread's `where` checks. */
+export const recordGeneration = 6;
+export const recordWords = 7;
+/** Record flags: it's the resource archetype, of the entity resources live on; it's reclaimed, matching no system. */
+export const resourceFlag = 1;
+export const reclaimedFlag = 2;
+export const storageWords = 10;
+export const storageComponent = 0;
+export const storageFlags = 1;
+export const storageColumn = 2;
+export const storageAdded = 3;
+export const storageChanged = 4;
+export const storageChunkAdded = 5;
+export const storageChunkChanged = 6;
+export const storageChunks = 7;
+export const storageBlockAdded = 8;
+export const storageBlockChanged = 9;
+/**
+ * Storage flags: it keeps ticks; it has a column in linear memory, a string's of handles included; its objects are a joined thread's, whose number is
+ * the flags from `threadShift` on, and its column holds each row's tag (`move-log.ts`); it's a shared component's,
+ * whose column is its archetype's value: a word of its length in UTF-16 code units, then its canonical text's.
+ */
+export const tickedFlag = 1;
+export const linearFlag = 2;
+export const remoteFlag = 4;
+export const sharedFlag = 8;
+export const threadShift = 8;
+const initialTable = 64;
+/** A directory for shared memory; without it, no other thread reads the memory, so there's none. */
+export const createLayoutDirectory = (memory) => {
+    if (!memory.shared)
+        return null;
+    const table = allocateArray(memory, Uint32Array, initialTable).fill(0);
+    const { header } = memory;
+    header[tableOffsetWord] = table.byteOffset;
+    header[tableLengthWord] = 0;
+    return { memory, header, words: new Int32Array(header.buffer, header.byteOffset, header.length), table, records: [], texts: [], entities: -1, guarded: false };
+};
+const writeEntities = ({ header }, entities) => {
+    header[entitiesWord + cursorField] = entities.cursor.byteOffset;
+    header[entitiesWord + freeField] = entities.free.byteOffset;
+    header[entitiesWord + freeCapacityField] = entities.free.length;
+    header[entitiesWord + archetypeField] = entities.archetype.byteOffset;
+    header[entitiesWord + rowField] = entities.row.byteOffset;
+    header[entitiesWord + generationField] = entities.generation.byteOffset;
+    header[entitiesWord + capacityField] = entities.archetype.length;
+    Atomics.store(header, entitiesWord + entitiesVersionField, entities.version);
+};
+/** The record for an archetype, allocated and entered in the table the first time it's flushed. */
+const recordOf = (directory, archetype) => {
+    const existing = directory.records[archetype.id];
+    if (existing !== undefined)
+        return existing;
+    const { memory, header } = directory;
+    if (archetype.id >= directory.table.length) {
+        const used = directory.table.length;
+        let length = used * 2;
+        while (length <= archetype.id)
+            length *= 2;
+        directory.table = growArray(memory, directory.table, Uint32Array, length, used).fill(0, used);
+        header[tableOffsetWord] = directory.table.byteOffset;
+    }
+    const record = allocateArray(memory, Uint32Array, recordWords + archetype.storages.length * storageWords);
+    directory.records[archetype.id] = record;
+    return record;
+};
+/** Each shared value's text an archetype holds, in the memory once, by its storages: 0 for a storage of another component. */
+const textsOf = (directory, archetype) => {
+    const known = directory.texts[archetype.id];
+    if (known !== undefined)
+        return known;
+    const offsets = archetype.storages.map(storage => {
+        const text = archetype.texts[storage.component];
+        if (text === undefined)
+            return 0;
+        const words = allocateArray(directory.memory, Uint32Array, 1 + Math.ceil(text.length / 2));
+        words[0] = text.length;
+        const units = new Uint16Array(words.buffer, words.byteOffset + 4, text.length);
+        for (let i = 0; i < text.length; i++)
+            units[i] = text.charCodeAt(i);
+        return words.byteOffset;
+    });
+    directory.texts[archetype.id] = offsets;
+    return offsets;
+};
+/** Lets go of the texts of an archetype's shared values, as it's reused for others: its next record writes theirs. */
+export const forgetTexts = (directory, archetype) => {
+    const known = directory.texts[archetype.id];
+    if (known === undefined)
+        return;
+    directory.texts[archetype.id] = undefined;
+    for (const offset of known) {
+        if (offset === 0)
+            continue;
+        const words = new Uint32Array(directory.memory.memory.buffer, offset, 1);
+        freeArray(directory.memory, { byteOffset: offset, byteLength: 4 * (1 + Math.ceil(words[0] / 2)) });
+    }
+};
+const writeArchetype = (directory, archetype) => {
+    const fresh = directory.records[archetype.id] === undefined;
+    const record = recordOf(directory, archetype);
+    const texts = archetype.texts.length === 0 ? null : textsOf(directory, archetype);
+    record[recordCapacity] = archetype.capacity;
+    record[recordEntities] = archetype.entities.byteOffset;
+    record[recordStorages] = archetype.storages.length;
+    record[recordFlags] = (archetype.resource ? resourceFlag : 0) | (archetype.reclaimed ? reclaimedFlag : 0);
+    record[recordGeneration] = archetype.generation;
+    record[recordCount] = archetype.count;
+    for (let s = 0; s < archetype.storages.length; s++) {
+        const storage = archetype.storages[s];
+        const base = recordWords + s * storageWords;
+        // A string's column of handles is in linear memory too, its records with it.
+        const linear = storage.layout.kind === "linear" || storage.layout.kind === "string";
+        const { remote } = storage;
+        record[base + storageComponent] = storage.component;
+        const text = texts === null ? 0 : texts[s];
+        record[base + storageFlags] = (storage.ticked ? tickedFlag : 0) | (linear ? linearFlag : 0) | (remote === null ? 0 : remoteFlag | (remote.thread << threadShift)) | (text === 0 ? 0 : sharedFlag);
+        record[base + storageColumn] = linear ? storage.views.u8.byteOffset : remote === null ? text : storage.tags.byteOffset;
+        record[base + storageAdded] = storage.ticked ? storage.added.byteOffset : 0;
+        record[base + storageChanged] = storage.ticked ? storage.changed.byteOffset : 0;
+        record[base + storageChunkAdded] = storage.ticked ? storage.chunkAdded.byteOffset : 0;
+        record[base + storageChunkChanged] = storage.ticked ? storage.chunkChanged.byteOffset : 0;
+        record[base + storageChunks] = storage.chunkAdded.length;
+        record[base + storageBlockAdded] = storage.ticked ? storage.blockAdded.byteOffset : 0;
+        record[base + storageBlockChanged] = storage.ticked ? storage.blockChanged.byteOffset : 0;
+    }
+    Atomics.store(record, recordVersion, archetype.version);
+    // Entered once complete, so a reader that finds it finds a whole record.
+    if (fresh)
+        directory.table[archetype.id] = record.byteOffset;
+};
+/**
+ * Writes the records of archetypes created or bumped since the last flush, the resource archetype's flagged, and the
+ * entity table's and the resource entity's if they moved. Runs at the end of each sync point and wherever registration
+ * changes layouts; allocates only for new records.
+ */
+export const flushDirectory = (directory, bumped, archetypes, entities, resourceEntity, counted) => {
+    if (directory === null)
+        return;
+    const resourceWord = resourceEntity < 0 ? 0 : (resourceEntity >>> 0) + 1;
+    if (directory.header[resourceEntityWord] !== resourceWord)
+        Atomics.store(directory.header, resourceEntityWord, resourceWord);
+    if (counted.length > 0)
+        flushCounts(directory, counted);
+    if (bumped.length === 0 && entities.version === directory.entities)
+        return;
+    if (entities.version !== directory.entities) {
+        writeEntities(directory, entities);
+        directory.entities = entities.version;
+    }
+    if (bumped.length === 0)
+        return;
+    let replaced = false;
+    for (let k = 0; k < bumped.length; k++) {
+        const archetype = bumped[k];
+        archetype.listed = false;
+        if (directory.records[archetype.id] !== undefined)
+            replaced = true;
+        writeArchetype(directory, archetype);
+    }
+    bumped.length = 0;
+    Atomics.store(directory.header, tableLengthWord, archetypes.length);
+    if (replaced)
+        Atomics.add(directory.header, replacedWord, 1);
+};
+/**
+ * A flush between sync points, as registration's: under the structure epoch, as a sync point's is, while a joined
+ * thread may read records.
+ */
+export const flushBetween = (directory, bumped, archetypes, entities, resourceEntity, counted) => {
+    if (directory === null)
+        return;
+    const guarding = directory.guarded && (bumped.length > 0 || counted.length > 0 || entities.version !== directory.entities);
+    if (guarding)
+        Atomics.add(directory.words, structureWord, 1);
+    flushDirectory(directory, bumped, archetypes, entities, resourceEntity, counted);
+    if (guarding)
+        endStructure(directory);
+};
+/** Writes the counts of archetypes whose count changed, those with records; a new archetype's comes with its record. */
+const flushCounts = (directory, counted) => {
+    for (let k = 0; k < counted.length; k++) {
+        const archetype = counted[k];
+        archetype.counted = false;
+        const record = directory.records[archetype.id];
+        if (record !== undefined)
+            record[recordCount] = archetype.count;
+    }
+    counted.length = 0;
+};
+/** Lists an archetype whose count changed for the next flush, while a joined thread may read counts. */
+export const countChanged = (counted, archetype) => {
+    if (archetype.counted)
+        return;
+    archetype.counted = true;
+    counted.push(archetype);
+};
+/**
+ * At the start of a sync point that applies anything, once a joined thread may read locations: the structure epoch
+ * turns odd, by an exchange, so the writes after it can't be seen before it.
+ */
+export const beginStructure = (directory) => {
+    if (directory !== null && directory.guarded)
+        Atomics.add(directory.words, structureWord, 1);
+};
+/**
+ * Once a sync point's directory writes are done: the structure epoch turns even, by a store, since only the world
+ * writes it, waking readers only when one waits on it.
+ */
+export const endStructure = (directory) => {
+    if (directory === null)
+        return;
+    const { words } = directory;
+    const epoch = words[structureWord];
+    if ((epoch & 1) === 0)
+        return;
+    Atomics.store(words, structureWord, epoch + 1);
+    if (Atomics.load(words, structureWaitersWord) !== 0)
+        Atomics.notify(words, structureWord);
+};
+//# sourceMappingURL=layout-directory.js.map

package/dist/implementation/world/layout-directory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-directory.js","sourceRoot":"","sources":["../../../src/implementation/world/layout-directory.ts"],"names":[],"mappings":"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"}

package/dist/implementation/world/lists.d.ts

@@ -0,0 +1,86 @@
+import type { Entity } from '../../interface/entity/entity.js';
+import { type Column, type Positional, type SpawnBatch, type Writer } from './staging.js';
+import { type State } from './state.js';
+/** Values by key, as spawns and adds read them. */
+export type Values = {
+    readonly [key: symbol]: unknown;
+};
+/** Spawns one entity of a list's components, writing its values into the list's batch. */
+export type Spawner = (values?: Values) => Entity;
+/** Where a shape's spawns go: its batch, and the components holding values, each with its key, column and writer. */
+export type Written = {
+    readonly batch: SpawnBatch;
+    readonly keys: readonly symbol[];
+    readonly columns: readonly Column[];
+    readonly writers: readonly Writer[];
+};
+/**
+ * A set of components commands named, by their keys: keys and ids in the order of the list that first named them, what
+ * each starts at when a spawn or add leaves it out, and, made on the first spawn, where spawns go and its spawner.
+ */
+export type ListShape = {
+    /** Its index among the world's lists, by which commands name it. */
+    readonly index: number;
+    /** By source archetype id: the archetype an add or a remove of these components leaves, once a sync point resolved it. */
+    readonly adding: number[];
+    readonly removing: number[];
+    readonly keys: readonly symbol[];
+    readonly ids: readonly number[];
+    readonly starts: readonly unknown[];
+    /** The positions of its shared components, whose values a spawner of it takes first. */
+    readonly shared: readonly number[];
+    written: Written | null;
+    spawner: Spawner | null;
+    /** Its spawners with constants, by their values (`presetSpawnerOf`). */
+    presets: PresetNode | null;
+};
+/**
+ * A level of a shape's spawners with constants: by the constant of the next component in the shape's order, the next
+ * level, the last one holding the spawner. A shared value is keyed by its number, a primitive by itself, other data
+ * by its text, and anything else by identity.
+ */
+type PresetNode = {
+    readonly next: Map<unknown, PresetNode>;
+    spawner: Spawner | null;
+    letGo: (() => void) | null;
+};
+/** A plain list named recently, found by its keys, copied once for its shape, since it may change. */
+export type Recent = {
+    keys: readonly unknown[];
+    shape: ListShape;
+};
+/**
+ * The index a list has: the program-wide one the plugin gave it, which never changes; for one made at runtime, the
+ * one it keeps while its keys are those it was resolved with; else -1. Both are read from one property, so a list of
+ * either kind is one lookup.
+ */
+export declare const listIndexOf: (list: readonly unknown[]) => number;
+/**
+ * The shape of a list of components, by its index (`listIndexOf`); for a list made at runtime without one, by its keys
+ * among the recent ones, else resolved, given an index it keeps and made recent. Lists of the same components in any
+ * order share a shape.
+ */
+export declare const listShapeOf: (state: State, list: readonly unknown[]) => ListShape;
+/** Where a shape's spawns go, resolved once. A constant's column holds nothing, so nothing is written or read for it. */
+export declare const writtenOf: (state: State, shape: ListShape) => Written;
+export type { Positional };
+/**
+ * Spawns of a shape taking values positionally in `order`, a site's key order: generated, else a loop over the
+ * writers. A key the shape doesn't name is ignored.
+ */
+export declare const positionalOf: (state: State, shape: ListShape, order: readonly unknown[]) => Positional;
+/**
+ * The spawner of a shape, made once: it writes each value it reads by key into the shape's batch, a tag or `undefined`
+ * as the component's start, then reserves the entity, so a value that throws leaves nothing behind.
+ */
+export declare const spawnerOf: (state: State, shape: ListShape) => Spawner;
+/** For tests of what a world holds: the levels of a shape's spawners with constants. */
+export declare const presetLevelsOf: (shape: ListShape) => number;
+/**
+ * The spawner of a shape with constants `preset`: the same function for a world, list and equal constants each time,
+ * found by each constant in turn, a level of the shape's spawners each (`PresetNode`). Its batch is the one of the
+ * shape's components and shared values, so its archetype, found by them, is resolved when the spawner is made, and
+ * made with the first sync point that commits a spawn of it. Every shared component is given a value of its type here,
+ * or the spawner throws. Other constants are encoded once and copied into each spawn; its call reads only the rest.
+ */
+export declare const presetSpawnerOf: (state: State, shape: ListShape, preset: object) => Spawner;

package/dist/implementation/world/lists.js

@@ -0,0 +1,258 @@
+import { archetypeIndexKey, internArchetype, labelOf } from '../../interface/registry/index.js';
+import { batchOf } from './batches.js';
+import { reserve } from './entities.js';
+import { claim, encodedIn, generated, noValues, openRow, writerOf } from './staging.js';
+import { cacheShared, exactTextOf, internShared } from './shared.js';
+import { commandIdOf } from './state.js';
+const recentCount = 8;
+/** Resolves a list, checking each key is a component commands may name, listed once. Throws otherwise. */
+const resolve = (state, list) => {
+    const ids = list.map(key => commandIdOf(state, key));
+    for (let k = 1; k < ids.length; k++) {
+        if (ids.indexOf(ids[k]) < k)
+            throw new Error(`A list of components lists "${labelOf(list[k])}" twice.`);
+    }
+    const keys = list.filter(key => typeof key === "symbol");
+    const name = [...ids].sort((a, b) => a - b).join(",");
+    // Symbols a module evaluated again makes are the same components, but values are keyed by the caller's own.
+    const shapes = state.lists.get(name) ?? [];
+    const found = shapes.find(shape => keys.every(key => shape.keys.includes(key)));
+    if (found !== undefined)
+        return found;
+    const shared = ids.flatMap((id, k) => state.shared[id] === undefined ? [] : [k]);
+    const shape = { index: state.shapes.length, adding: [], removing: [], keys, ids, starts: ids.map(id => state.starts[id]), shared, written: null, spawner: null, presets: null };
+    state.lists.set(name, [...shapes, shape]);
+    state.shapes.push(shape);
+    return shape;
+};
+/**
+ * The index a list has: the program-wide one the plugin gave it, which never changes; for one made at runtime, the
+ * one it keeps while its keys are those it was resolved with; else -1. Both are read from one property, so a list of
+ * either kind is one lookup.
+ */
+export const listIndexOf = (list) => {
+    const index = Reflect.get(list, archetypeIndexKey);
+    return typeof index === "number" ? index : isKept(index) && sameKeys(index.keys, list) ? index.index : -1;
+};
+/**
+ * The shape of a list of components, by its index (`listIndexOf`); for a list made at runtime without one, by its keys
+ * among the recent ones, else resolved, given an index it keeps and made recent. Lists of the same components in any
+ * order share a shape.
+ */
+export const listShapeOf = (state, list) => {
+    const index = listIndexOf(list);
+    return (index >= 0 ? state.byIndex[index] : undefined) ?? shapeOfList(state, list, index);
+};
+/** A list's shape, other than one already resolved by its index. */
+const shapeOfList = (state, list, index) => {
+    if (index >= 0) {
+        const shape = resolve(state, list);
+        state.byIndex[index] = shape;
+        return shape;
+    }
+    const { recent } = state;
+    for (let r = 0; r < recent.length; r++)
+        if (sameKeys(recent[r].keys, list))
+            return recent[r].shape;
+    // Lists of these keys made on every call share one index, so a shape seen before allocates nothing here.
+    const interned = internArchetype(list);
+    const shape = state.byIndex[interned.index] ?? (state.byIndex[interned.index] = resolve(state, list));
+    if (recent.length < recentCount)
+        recent.push({ keys: interned.keys, shape });
+    else {
+        const slot = recent[state.nextRecent = (state.nextRecent + 1) % recentCount];
+        slot.keys = interned.keys;
+        slot.shape = shape;
+    }
+    // A list keeps the record of its keys' index, so naming it again is one lookup while it holds them.
+    const kept = Reflect.get(list, archetypeIndexKey);
+    if (kept === undefined && Object.isExtensible(list)) {
+        record.value = interned;
+        Object.defineProperty(list, archetypeIndexKey, record);
+    }
+    else if (isKept(kept))
+        Reflect.set(list, archetypeIndexKey, interned);
+    return shape;
+};
+/** The descriptor a list's record is defined by, its value set for each: writable, since the list may change. */
+const record = { value: null, writable: true };
+/** Whether an index property holds a list's record: only this module puts an object there, and indexes are numbers. */
+const isKept = (value) => typeof value === "object" && value !== null;
+/** Whether a list holds exactly the keys copied from one before. */
+const sameKeys = (keys, list) => {
+    const length = list.length;
+    if (keys.length !== length)
+        return false;
+    for (let k = 0; k < length; k++)
+        if (keys[k] !== list[k])
+            return false;
+    return true;
+};
+/** Where a shape's spawns go, resolved once. A constant's column holds nothing, so nothing is written or read for it. */
+export const writtenOf = (state, shape) => {
+    if (shape.written !== null)
+        return shape.written;
+    shape.written = writtenInto(state, shape, batchOf(state, shape.ids));
+    return shape.written;
+};
+/** Where a shape's spawns into `batch` go: its columns holding values, each with its key and writer. */
+const writtenInto = (state, shape, batch) => {
+    const held = shape.ids.flatMap((id, k) => state.layouts[id].kind === "constant" ? [] : [k]);
+    const columns = held.map(k => batch.columns[batch.ids.indexOf(shape.ids[k])]);
+    return { batch, keys: held.map(k => shape.keys[k]), columns, writers: held.map((k, c) => writerOf(columns[c], shape.starts[k])) };
+};
+/** Throws for a spawner without constants of a shape with shared components, whose values choose the archetype. */
+const refuseShared = (shape) => {
+    const first = shape.shared[0];
+    if (first !== undefined)
+        throw new Error(`A spawn of "${labelOf(shape.keys[first])}", a shared component, takes its value first: commands.spawn(components, { [key]: value }).`);
+};
+/** Spawns by reading each value by key in a loop: where code can't be generated. */
+const loopSpawner = (state, { batch, keys, writers }) => {
+    const { entities } = state;
+    const count = keys.length;
+    return (values = noValues) => {
+        const row = openRow(batch);
+        for (let k = 0; k < count; k++)
+            writers[k](row, values[keys[k]]);
+        const entity = reserve(entities);
+        claim(batch, entity);
+        return entity;
+    };
+};
+/**
+ * Spawns of a shape taking values positionally in `order`, a site's key order: generated, else a loop over the
+ * writers. A key the shape doesn't name is ignored.
+ */
+export const positionalOf = (state, shape, order) => {
+    refuseShared(shape);
+    const { batch, keys, columns, writers } = writtenOf(state, shape);
+    const at = keys.map(key => order.indexOf(key));
+    const made = generated(state.entities, reserve, batch, order.map((_, k) => `v${k}`), keys, columns, writers, k => at[k] < 0 ? "undefined" : `v${at[k]}`);
+    if (made !== null)
+        return made;
+    const { entities } = state;
+    return (...values) => {
+        const row = openRow(batch);
+        for (let k = 0; k < writers.length; k++)
+            writers[k](row, at[k] < 0 ? undefined : values[at[k]]);
+        const entity = reserve(entities);
+        claim(batch, entity);
+        return entity;
+    };
+};
+/**
+ * The spawner of a shape, made once: it writes each value it reads by key into the shape's batch, a tag or `undefined`
+ * as the component's start, then reserves the entity, so a value that throws leaves nothing behind.
+ */
+export const spawnerOf = (state, shape) => shape.spawner ?? makeSpawner(state, shape);
+/** Makes a shape's spawner, the first time it spawns. */
+const makeSpawner = (state, shape) => {
+    refuseShared(shape);
+    const written = writtenOf(state, shape);
+    const { batch, keys, columns, writers } = written;
+    shape.spawner = generated(state.entities, reserve, batch, ["values = none"], keys, columns, writers, k => `values[k${k}]`) ?? loopSpawner(state, written);
+    return shape.spawner;
+};
+/** For tests of what a world holds: the levels of a shape's spawners with constants. */
+export const presetLevelsOf = (shape) => {
+    const count = (node) => {
+        let levels = 0;
+        for (const child of node.next.values())
+            levels += 1 + count(child);
+        return levels;
+    };
+    return shape.presets === null ? 0 : count(shape.presets);
+};
+/** What keys a component given no constant at its level of a shape's spawners. */
+const absent = Symbol("absent");
+/** What keys a constant of -0, which a map's keys don't tell from 0. */
+const negativeZero = Symbol("negativeZero");
+/**
+ * The spawner of a shape with constants `preset`: the same function for a world, list and equal constants each time,
+ * found by each constant in turn, a level of the shape's spawners each (`PresetNode`). Its batch is the one of the
+ * shape's components and shared values, so its archetype, found by them, is resolved when the spawner is made, and
+ * made with the first sync point that commits a spawn of it. Every shared component is given a value of its type here,
+ * or the spawner throws. Other constants are encoded once and copied into each spawn; its call reads only the rest.
+ */
+export const presetSpawnerOf = (state, shape, preset) => {
+    let node = shape.presets ??= { next: new Map(), spawner: null, letGo: null };
+    const { keys, ids } = shape;
+    for (let k = 0; k < keys.length; k++) {
+        const given = Reflect.get(preset, keys[k]);
+        const values = state.shared[ids[k]];
+        let part;
+        if (values !== undefined) {
+            if (given === undefined)
+                throw new Error(`A spawn of "${labelOf(keys[k])}", a shared component, takes its value first: commands.spawn(components, { [key]: value }).`);
+            part = internShared(values, given);
+            if (part === -1)
+                throw new Error(`"${labelOf(keys[k])}" isn't given one of its type's values: ${labelOf(given)}.`);
+        }
+        else
+            part = given === undefined ? absent : Object.is(given, -0) ? negativeZero : typeof given === "object" && given !== null ? exactTextOf(given) ?? given : given;
+        let next = node.next.get(part);
+        if (next === undefined) {
+            next = { next: new Map(), spawner: null, letGo: null };
+            node.next.set(part, next);
+            if (values !== undefined && typeof part === "number")
+                letGoWith(values, part, node, next);
+        }
+        node = next;
+    }
+    return node.spawner ??= makePresetSpawner(state, shape, preset);
+};
+/** Throws for a spawn giving a component its constants gave. */
+const refuseGiven = (key) => {
+    throw new Error(`A spawn gives "${labelOf(key)}" in both its calls: each component's value comes from one.`);
+};
+/**
+ * Lets go of a level of a shape's spawners found by shared value `number`, under `parent`, once that value is dropped,
+ * so levels don't pile up as values come and go: the levels below it let go of what they registered too.
+ */
+const letGoWith = (values, number, parent, node) => {
+    node.letGo = cacheShared(values, number, () => {
+        if (parent.next.get(number) === node)
+            parent.next.delete(number);
+        unregisterBelow(node);
+    });
+};
+/** Unregisters every level below `node` from the values that would drop it, as `node` is dropped itself. */
+const unregisterBelow = (node) => {
+    for (const child of node.next.values()) {
+        child.letGo?.();
+        unregisterBelow(child);
+    }
+};
+/** Makes the spawner of a shape with constants, the first time those constants are given. */
+const makePresetSpawner = (state, shape, preset) => {
+    const shared = [];
+    for (const k of shape.shared) {
+        const values = state.shared[shape.ids[k]];
+        if (values !== undefined)
+            shared[shape.ids[k]] = internShared(values, Reflect.get(preset, shape.keys[k]));
+    }
+    const written = writtenInto(state, shape, batchOf(state, shape.ids, shared));
+    const { batch, keys, columns, writers } = written;
+    const constants = keys.map(key => Reflect.get(preset, key));
+    const encoded = columns.map((column, c) => constants[c] === undefined ? null : encodedIn(column, constants[c]));
+    // Every key the constants give, shared ones included, which a spawn's values mustn't give again.
+    const given = shape.keys.filter(key => Reflect.get(preset, key) !== undefined);
+    const guarded = { keys: given, refuse: refuseGiven };
+    const made = generated(state.entities, reserve, batch, ["values = none"], keys.map((key, c) => constants[c] === undefined ? key : constants[c]), columns, writers, k => constants[k] === undefined ? `values[k${k}]` : `k${k}`, encoded, guarded);
+    if (made !== null)
+        return made;
+    const { entities } = state;
+    return (values = noValues) => {
+        for (const key of given)
+            if (values[key] !== undefined)
+                refuseGiven(key);
+        const row = openRow(batch);
+        for (let k = 0; k < keys.length; k++)
+            writers[k](row, constants[k] === undefined ? values[keys[k]] : constants[k]);
+        const entity = reserve(entities);
+        claim(batch, entity);
+        return entity;
+    };
+};
+//# sourceMappingURL=lists.js.map