@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/reports.test-helper.ts

@@ -1,117 +0,0 @@
-import { Report } from "../../interface/report/report.js";
-import { retainedRuns } from "./reports.js";
-import { System } from "../../interface/system/system.js";
-import type { Input } from "../../interface/system/input.js";
-import type { World } from "../../interface/world/world.js";
-
-/** A run's report as data: its errors, empty when it has none, and what it dropped. */
-export type Reported = {
-    readonly failures: readonly Report.Failure[];
-    readonly skipped: readonly string[];
-    readonly dropped: number;
-    readonly warnings: readonly Report.Warning[];
-};
-
-/** By world, its reader of reports and the reads asked of it, in the order their runs run: each the run whose report it wants, and what it found. */
-type Reader = { readonly system: System; readonly asked: { readonly run: number; found: Reported | null; values: Report[typeof Report.run] | null }[] };
-const readers = new WeakMap<World, Reader>();
-
-const none: readonly never[] = [];
-
-const readerOf = (world: World): Reader => {
-    const known = readers.get(world);
-    if (known !== undefined) return known;
-    const asked: Reader["asked"] = [];
-    const system = System.create({ name: "test/readReport", observer: true, components: { read: [Report.run] }, lookup: { errorsOf: { read: [Report.errors] } } }, (row, { lookup }) => {
-        const read = asked[0];
-        const values = row[Report.run];
-        if (read === undefined || (read.run >= 0 ? values.number !== read.run : values.number <= (read.values?.number ?? -1))) return;
-        const errors = lookup.errorsOf(row.entity)?.[Report.errors] ?? null;
-        read.values = values;
-        read.found = errors === null
-            ? { failures: none, skipped: none, dropped: values.dropped, warnings: none }
-            : { failures: errors.failures, skipped: errors.skipped, dropped: values.dropped, warnings: errors.warnings };
-    });
-    const reader = { system, asked };
-    readers.set(world, reader);
-    return reader;
-};
-
-const readOf = async (world: World, run: number) => {
-    const { system, asked } = readerOf(world);
-    const read: Reader["asked"][number] = { run, found: null, values: null };
-    asked.push(read);
-    try {
-        await world.run(system);
-    }
-    finally {
-        const left = asked.indexOf(read);
-        if (left >= 0) asked.splice(left, 1);
-    }
-    return read;
-};
-
-/** Run `run`'s report, read once by an observer system's run over every report; throws when there's none. */
-export const reportOf = async (world: World, run: number): Promise<Reported> => {
-    const { found } = await readOf(world, run);
-    if (found === null) throw new Error(`Run ${run} has no report.`);
-    return found;
-};
-
-/** Run `run`'s `Report.run`; throws when it has no report. */
-export const runOf = async (world: World, run: number): Promise<Report[typeof Report.run]> => {
-    const { values } = await readOf(world, run);
-    if (values === null) throw new Error(`Run ${run} has no report.`);
-    return values;
-};
-
-/**
- * Runs a system, then reads the next run's report, which holds what the system's run found after its own was written:
- * what its observer pass threw.
- */
-export const runThenNext = async <I>(world: World, system: System<I>, ...input: Input<NoInfer<I>>): Promise<Reported> => {
-    await world.run(system, ...input);
-    // The reader's own run is the newest: its report holds what was deferred to it.
-    const { found } = await readOf(world, -1);
-    if (found === null) throw new Error("The next run has no report.");
-    return found;
-};
-
-/** Runs a system, then reads its run's report. */
-export const runReported = async <I>(world: World, system: System<I>, ...input: Input<NoInfer<I>>): Promise<Reported> =>
-    reportOf(world, await world.run(system, ...input));
-
-/**
- * Follows a world's reports with an observer system it adds: `seen` lists each report as a pass found it changed, and
- * `until` resolves with the first one a test passes, once one does.
- */
-export const followReports = (world: World) => {
-    type Seen = { readonly run: number; readonly failures: readonly Report.Failure[] };
-    const seen: Seen[] = [];
-    const waiting: (() => void)[] = [];
-    const system = System.create({ name: "test/followReports", observer: true, components: { read: [Report.run, Report.errors], changed: [Report.errors] } }, row => {
-        seen.push({ run: row[Report.run].number, failures: row[Report.errors].failures });
-        for (const wake of waiting.splice(0)) wake();
-    });
-    world.add(system);
-    const until = async (test: (report: Seen) => boolean): Promise<Seen> => {
-        for (;;) {
-            const found = seen.find(test);
-            if (found !== undefined) return found;
-            await new Promise<void>(resolve => waiting.push(resolve));
-        }
-    };
-    return { seen, until, stop: () => world.remove(system) };
-};
-
-/** Despawns every report, for tests that compare entity order with a world that has none: later runs spawn them again. */
-export const dropReports = System.create({ name: "test/dropReports", components: { has: [Report.run] } }, (row, { commands }) => {
-    commands.despawn(row.entity);
-});
-
-const nothing = System.create({ name: "test/nothing" }, () => {});
-
-/** Runs a world until every report it keeps is spawned, so later runs reuse their entities and spawn none. */
-export const fillReports = async (world: World): Promise<void> => {
-    for (let k = 0; k < retainedRuns; k++) await world.run(nothing);
-};

package/src/implementation/world/reports.test.ts

@@ -1,167 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Component, Index, Report, Resource, System, clock, workers } from "../../index.js";
-import { createWorld } from "./create.js";
-import { retainedRuns } from "./reports.js";
-import { reportOf, runOf } from "./reports.test-helper.js";
-
-const amount = Symbol("reportsTest/amount");
-const level = Symbol("reportsTest/level");
-declare module "@adobe/ecs" {
-    interface Components {
-        [amount]: { type: number };
-    }
-    interface Resources {
-        [level]: { type: number };
-    }
-}
-Component.register(amount, { type: { type: "number" } });
-Resource.register(level, { type: { type: "number", default: 0 } });
-
-const nothing = System.create({ name: "reportsTest/nothing" }, () => {});
-const fail = System.create({ name: "reportsTest/fail" }, () => { throw new Error("run failed"); });
-const raise = System.create({ name: "reportsTest/raise", resources: { write: [level] } }, ({ resources }) => { resources[level] += 1; });
-const idle = System.create({ name: "reportsTest/idle", observer: true }, () => {});
-const spawn = System.create({ name: "reportsTest/spawn" }, ({ commands }) => { commands.spawn([amount])({ [amount]: 1 }); });
-const despawnAll = System.create({ name: "reportsTest/despawnAll", components: { has: [amount] } }, (row, { commands }) => {
-    commands.despawn(row.entity);
-    commands.despawn(row.entity);
-});
-const failingObserver = System.create({ name: "reportsTest/failingObserver", observer: true, resources: { read: [level], changed: [level] } }, ({ resources }) => {
-    if (resources[level] > 0) throw new Error("observer failed");
-});
-
-/** What a logger following reports saw, by pass: each changed report's run and failures' messages. */
-const logged: (readonly [number, readonly string[]])[] = [];
-const logger = System.create({ name: "reportsTest/logger", observer: true, components: { read: [Report.run, Report.errors], changed: [Report.errors] } }, row => {
-    logged.push([row[Report.run].number, row[Report.errors].failures.map(failure => failure.message)]);
-});
-
-/** The run numbers of every report, in entity order, and of those with errors. */
-let numbers: number[] = [];
-let withErrors: number[] = [];
-const allReports = Index.create({ name: "reportsTest/allReports", key: [], components: { has: [Report.run] } });
-const erredReports = Index.create({ name: "reportsTest/erredReports", key: [], components: { has: [Report.run, Report.errors] } });
-const listReports = System.create({ name: "reportsTest/listReports", observer: true, lookup: { all: { index: allReports, read: [Report.run] }, erred: { index: erredReports, read: [Report.run] } } }, ({ lookup }) => {
-    const all = lookup.all();
-    numbers = [];
-    for (let i = 0; i < all.length; i++) numbers.push(all.at(i)[Report.run].number);
-    const erred = lookup.erred();
-    withErrors = [];
-    for (let i = 0; i < erred.length; i++) withErrors.push(erred.at(i)[Report.run].number);
-});
-
-const inline = () => createWorld({ [workers]: 0 });
-const sorted = (values: readonly number[]) => [...values].sort((a, b) => a - b);
-
-describe("reports", () => {
-    it("number every run in order, one of observer systems alone included, each with a report", async () => {
-        await using world = inline();
-        expect(await world.run(nothing)).toBe(1);
-        expect(await world.run(raise)).toBe(2);
-        expect(await world.run(idle)).toBe(3);
-        expect(await reportOf(world, 2)).toEqual({ failures: [], skipped: [], dropped: 0, warnings: [] });
-        const listed = await world.run(listReports);
-        expect(sorted(numbers)).toEqual([1, 2, 3, 4, listed]);
-        expect(withErrors).toEqual([]);
-    });
-
-    it("say what a run ran: its systems, on main with no joined thread claiming it, and how long it took", async () => {
-        await using world = inline();
-        const both = await world.run(System.create([nothing, raise]));
-        const values = await runOf(world, both);
-        expect({ ...values, elapsed: 0 }).toEqual({ number: both, elapsed: 0, systems: 2, workers: 0, joined: 0, main: true, gpu: false, dropped: 0 });
-        expect(values.elapsed).toBeGreaterThanOrEqual(0);
-        const alone = await runOf(world, await world.run(idle));
-        expect({ ...alone, elapsed: 0 }).toEqual({ number: alone.number, elapsed: 0, systems: 0, workers: 0, joined: 0, main: false, gpu: false, dropped: 0 });
-    });
-
-    it("give a failed run errors, which an observer system sees in that run's pass, and a dropping run only its count", async () => {
-        await using world = inline();
-        logged.length = 0;
-        world.add(logger);
-        const failed = await world.run(fail);
-        expect(logged).toEqual([[failed, ["run failed"]]]);
-        const { failures } = await reportOf(world, failed);
-        expect(failures.map(({ kind, name, message }) => [kind, name, message])).toEqual([["system", "reportsTest/fail", "run failed"]]);
-        await world.run(spawn);
-        const dropping = await world.run(despawnAll);
-        expect(await reportOf(world, dropping)).toEqual({ failures: [], skipped: [], dropped: 1, warnings: [] });
-        expect(logged).toHaveLength(1);
-        await world.run(listReports);
-        expect(withErrors).toEqual([failed]);
-        world.remove(logger);
-    });
-
-    it("write each report's errors once, an observer pass's failures in the next run's report", async () => {
-        await using world = inline();
-        logged.length = 0;
-        world.add(failingObserver);
-        world.add(logger);
-        const raised = await world.run(raise);
-        expect(logged).toEqual([]);
-        expect((await reportOf(world, raised)).failures).toEqual([]);
-        // The reader's run, the next, holds them, and the logger saw them in its pass.
-        const { failures } = await reportOf(world, raised + 1);
-        expect(failures.map(({ name, message }) => [name, message])).toEqual([["reportsTest/failingObserver", "observer failed"]]);
-        expect(logged).toEqual([[raised + 1, ["observer failed"]]]);
-        // A failed run's report holds its own failures; its pass's are in the next.
-        const both = System.create([fail, raise]);
-        const failed = await world.run(both);
-        expect((await reportOf(world, failed)).failures.map(({ message }) => message)).toEqual(["run failed"]);
-        expect((await reportOf(world, failed + 1)).failures.map(({ message }) => message)).toEqual(["observer failed"]);
-        expect(logged.slice(1)).toEqual([[failed, ["run failed"]], [failed + 1, ["observer failed"]]]);
-    });
-
-    it(`keep the last ${retainedRuns} runs' reports, a later run taking the oldest one's entity and dropping its errors`, async () => {
-        await using world = inline();
-        const first = await world.run(fail);
-        const second = await world.run(fail);
-        while (await world.run(nothing) < first + retainedRuns - 2);
-        await world.run(listReports);
-        expect(numbers).toHaveLength(retainedRuns);
-        expect(sorted(withErrors)).toEqual([first, second]);
-        // This run takes the first report's entity, and its errors go.
-        const next = await world.run(listReports);
-        expect(numbers).toHaveLength(retainedRuns);
-        expect(sorted(numbers)[0]).toBe(second);
-        expect(sorted(numbers).at(-1)).toBe(next);
-        expect(withErrors).toEqual([second]);
-    });
-
-    it("write a reused report's errors in place when its run has errors too, and a logger sees each run's own", async () => {
-        await using world = inline();
-        logged.length = 0;
-        world.add(logger);
-        const failWith = System.create({ name: "reportsTest/failWith", input: { type: "object", properties: { k: { type: "integer" } } } }, ({ input }) => { throw new Error(`run ${input.k}`); });
-        for (let k = 0; k < retainedRuns; k++) await world.run(failWith, { k });
-        logged.length = 0;
-        const reused = await world.run(failWith, { k: retainedRuns });
-        expect(logged).toEqual([[reused, [`run ${retainedRuns}`]]]);
-        expect((await reportOf(world, reused)).failures.map(({ message }) => message)).toEqual([`run ${retainedRuns}`]);
-        await world.run(listReports);
-        expect(numbers).toHaveLength(retainedRuns);
-        world.remove(logger);
-    });
-
-    it("number ticks with runs, apart from the clock's tick, and report a failing tick's systems", async () => {
-        await using world = inline();
-        logged.length = 0;
-        world.add(logger);
-        world.add(fail);
-        let ticked = (): void => {};
-        // Its first pass passes its filter; only a tick writes the clock after.
-        let passes = 0;
-        const watchTicks = System.create({ name: "reportsTest/watchTicks", observer: true, resources: { changed: [clock] } }, () => {
-            if (++passes > 1) ticked();
-        });
-        world.add(watchTicks);
-        const tick = new Promise<void>(resolve => { ticked = resolve; });
-        const run = await world.run(nothing);
-        await tick;
-        const next = await world.run(nothing);
-        expect(next).toBeGreaterThan(run + 1);
-        const tickRuns = logged.map(([number]) => number).filter(number => number > run && number < next);
-        expect(tickRuns.length).toBeGreaterThan(0);
-        expect(logged.find(([number]) => number === tickRuns[0])?.[1]).toEqual(["run failed"]);
-    });
-});

package/src/implementation/world/reports.ts

@@ -1,203 +0,0 @@
-import { Report } from '../../interface/report/report.js';
-import type { Failure, Warning } from '../../interface/report/failure.js';
-import { stampChanged } from './archetype.js';
-import { addCommand, createBuffer, pushCommand, pushComponent, removeCommand, spawnCommand, type CommandBuffer } from './buffer.js';
-import { writeCell } from './cells.js';
-import type { Views } from '../../interface/registry/layout.js';
-import { pushValues } from './commands.js';
-import { locate, reserve } from './entities.js';
-import type { RunReport } from './failures.js';
-import { idOf, type State } from './state.js';
-
-/** How many runs keep their reports: past that, each run's report reuses the oldest one's entity. */
-export const retainedRuns = 256;
-
-/** What a run reports in `Report.run`. */
-export type RunValues = {
-    number: number;
-    elapsed: number;
-    systems: number;
-    workers: number;
-    joined: number;
-    main: boolean;
-    gpu: boolean;
-    dropped: number;
-};
-
-type Errors = { readonly failures: readonly Failure[]; readonly skipped: readonly string[]; readonly warnings: readonly Warning[] };
-
-/**
- * A report entity, of the run that last took it. `errors` is what its `Report.errors` holds, or will once commands
- * queued for it apply; null without. `own` tells whether those are its run's, not an earlier run's it reuses.
- */
-export type Slot = { entity: number; run: number; errors: Errors | null; own: boolean };
-
-/** Whether a run has nothing for `Report.errors`. */
-export const isClean = (report: RunReport): boolean => report.failures.length === 0 && report.skipped.length === 0 && report.warnings.length === 0;
-
-const none: readonly never[] = [];
-const noErrors: Errors = { failures: none, skipped: none, warnings: none };
-
-/** Fields of `Report.run`, in no particular order: what `createRunWriter` writes. */
-const runFields = ["number", "elapsed", "systems", "workers", "joined", "main", "gpu", "dropped"] as const satisfies readonly (keyof RunValues)[];
-
-/** A writer of `RunValues` into a storage of `Report.run`, by the leaf of each field in `layout`. */
-const createRunWriter = (layout: State["layouts"][number]) => {
-    if (layout.kind !== "linear") throw new Error("Report.run isn't a struct.");
-    const leafOf = (field: string) => {
-        const leaf = layout.leaves.find(each => each.path[0] === field);
-        if (leaf === undefined) throw new Error(`Report.run has no ${field}.`);
-        return leaf;
-    };
-    const [number, elapsed, systems, workers, joined, main, gpu, dropped] = runFields.map(leafOf);
-    return (views: Views, row: number, values: RunValues): void => {
-        views[number.view][row * number.unitStride + number.unitOffset] = values.number;
-        views[elapsed.view][row * elapsed.unitStride + elapsed.unitOffset] = values.elapsed;
-        views[systems.view][row * systems.unitStride + systems.unitOffset] = values.systems;
-        views[workers.view][row * workers.unitStride + workers.unitOffset] = values.workers;
-        views[joined.view][row * joined.unitStride + joined.unitOffset] = values.joined;
-        views[main.view][row * main.unitStride + main.unitOffset] = values.main ? 1 : 0;
-        views[gpu.view][row * gpu.unitStride + gpu.unitOffset] = values.gpu ? 1 : 0;
-        views[dropped.view][row * dropped.unitStride + dropped.unitOffset] = values.dropped;
-    };
-};
-
-/**
- * The world's reports: an entity for each of the last `retainedRuns` runs and ticks. Each run takes one as it starts:
- * a new one, spawned by its own sync point, until that many are, then the oldest. Once its sync point is done, its
- * `Report.run` is written in place, stamped so `changed` filters see it. `Report.errors` is written in place too when
- * the entity holds it already, so a reused entity changes archetype only when its run's errors come or go; adding or
- * removing it joins the run's sync point when known before it, else applies with `applyAlone`.
- */
-export const createReports = (state: State, applyAlone: (buffer: CommandBuffer) => Promise<void> | null) => {
-    const runId = idOf(state, Report.run);
-    const errorsId = idOf(state, Report.errors);
-    state.meta.add(runId).add(errorsId);
-    const slots: Slot[] = [];
-    /** The slot the next run takes once every one is spawned. */
-    let oldest = 0;
-    /** The slot the last run took. */
-    let last: Slot | null = null;
-
-    /** The storage and row of a slot's component `id`, while its entity holds it. */
-    const cellOf = (slot: Slot, id: number) => {
-        const index = locate(state.entities, slot.entity);
-        if (index < 0) return null;
-        const storage = state.archetypes[state.entities.archetype[index]]?.storageById[id];
-        return storage === undefined ? null : { storage, row: state.entities.row[index] };
-    };
-
-    /** Writes `Report.run` field by field through its layout's leaves, without the general writer's walk. */
-    const writeRun = createRunWriter(state.layouts[runId]);
-
-    /** Writes `errors` into a slot: in place when its entity holds them, stamped; else by an add, queued or alone. */
-    const putErrors = (slot: Slot, errors: Errors, queue: boolean): Promise<void> | null => {
-        const pending = slot.errors !== null && cellOf(slot, errorsId) === null;
-        slot.errors = errors;
-        slot.own = true;
-        const cell = cellOf(slot, errorsId);
-        if (cell !== null) {
-            writeCell(cell.storage, cell.row, errors);
-            stampChanged(cell.storage, cell.row, ++state.tick);
-            return null;
-        }
-        const buffer = createBuffer();
-        pushValues(state, buffer, addCommand, slot.entity, { [Report.errors]: errors });
-        if (queue || pending) {
-            state.queued.push({ buffer, guarded: false });
-            return null;
-        }
-        return applyAlone(buffer);
-    };
-
-    /**
-     * Takes run `run`'s slot: a new entity, spawned by commands queued for the next sync point, until every one is,
-     * then the oldest, or a new one in its place when a system despawned it.
-     */
-    const take = (run: number): Slot => {
-        let slot: Slot;
-        if (slots.length < retainedRuns) {
-            slot = { entity: -1, run, errors: null, own: false };
-            slots.push(slot);
-        }
-        else {
-            slot = slots[oldest];
-            oldest = (oldest + 1) % retainedRuns;
-            slot.run = run;
-            slot.own = false;
-            if (locate(state.entities, slot.entity) >= 0) return last = slot;
-            slot.errors = null;
-        }
-        slot.entity = reserve(state.entities);
-        const buffer = createBuffer();
-        pushValues(state, buffer, spawnCommand, slot.entity, {
-            [Report.run]: { number: run, elapsed: 0, systems: 0, workers: 0, joined: 0, main: false, gpu: false, dropped: 0 } satisfies RunValues,
-        });
-        state.queued.push({ buffer, guarded: false });
-        return last = slot;
-    };
-
-    return {
-        /** The slot the last run took. */
-        lastSlot: (): Slot => {
-            if (last === null) throw new Error("No run took a report yet.");
-            return last;
-        },
-        /** Takes the report of run `run`, which is about to run: what that takes joins the run's own sync point. */
-        begin: take,
-        /** Takes run `run`'s report between runs: what that takes applies as a sync point of its own. */
-        beginAlone: (run: number): Slot | Promise<Slot> => {
-            const queued = state.queued.length;
-            const slot = take(run);
-            if (state.queued.length === queued) return slot;
-            const applying = applyAlone(state.queued.splice(queued, 1)[0].buffer);
-            return applying === null ? slot : applying.then(() => slot);
-        },
-        /**
-         * Puts, for the run that took the last slot, `Report.errors` for what went wrong before its sync point:
-         * failures, skipped systems and the first `warningCount` warnings, copied, since the run's lists grow.
-         */
-        beforeSync: (failures: readonly Failure[] | null, skipped: readonly string[] | null, warnings: readonly Warning[], warningCount: number): void => {
-            if (last === null || (failures === null && skipped === null && warningCount === 0)) return;
-            const errors = { failures: failures === null ? none : failures.slice(), skipped: skipped === null ? none : skipped.slice(), warnings: warningCount === 0 ? none : warnings.slice(0, warningCount) };
-            void putErrors(last, errors, true);
-        },
-        /**
-         * Writes run `run`'s report into its slot once its sync point is done: `Report.run`, then its errors unless
-         * they were put before it, or clears those an earlier run left. A report's errors are written once: failures
-         * found after go to `defer`, for the next report. While tails run on joined threads, a removal waits for the
-         * next sync point, the errors emptied meanwhile.
-         */
-        finish: (slot: Slot, values: RunValues, report: RunReport, tailsRun: boolean, defer: (failures: readonly Failure[]) => void): Promise<void> | null => {
-            if (slot.run !== values.number) return null;
-            const cell = cellOf(slot, runId);
-            if (cell === null) return null;
-            writeRun(cell.storage.views, cell.row, values);
-            stampChanged(cell.storage, cell.row, ++state.tick);
-            if (!isClean(report)) {
-                const given = slot.own ? slot.errors : null;
-                if (given === null) return putErrors(slot, { failures: report.failures, skipped: report.skipped, warnings: report.warnings }, tailsRun);
-                // Its errors are written once: failures found since go to the next report.
-                if (report.failures.length > given.failures.length) defer(report.failures.slice(given.failures.length));
-                return null;
-            }
-            if (slot.errors === null || slot.own) return null;
-            const held = cellOf(slot, errorsId);
-            if (held !== null) {
-                writeCell(held.storage, held.row, noErrors);
-                stampChanged(held.storage, held.row, ++state.tick);
-            }
-            slot.errors = null;
-            const buffer = createBuffer();
-            pushCommand(buffer, removeCommand, slot.entity);
-            pushComponent(buffer, errorsId, undefined);
-            if (tailsRun) {
-                state.queued.push({ buffer, guarded: false });
-                return null;
-            }
-            return applyAlone(buffer);
-        },
-    };
-};
-
-export type Reports = ReturnType<typeof createReports>;

package/src/interface/archetype/archetype.ts

@@ -1,3 +0,0 @@
-export type Archetype = never;
-
-export * as Archetype from './index.js';

package/src/interface/archetype/archetype.type-test.ts

@@ -1,37 +0,0 @@
-import { Resource } from '../resource/resource.js';
-import { Component } from '../component/component.js';
-import { Archetype, System } from "@adobe/ecs";
-
-const position = Symbol("archetypeTypeTest/position");
-const velocity = Symbol("archetypeTypeTest/velocity");
-const scale = Symbol("archetypeTypeTest/scale");
-declare module "@adobe/ecs" {
-    interface Components {
-        [position]: { type: number };
-        [velocity]: { type: number };
-    }
-    interface Resources {
-        [scale]: { type: number };
-    }
-}
-Component.register(position, { type: { type: "number" } });
-Component.register(velocity, { type: { type: "number" } });
-Resource.register(scale, { type: { type: "number", default: 0 } });
-
-type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
-const expectType = <T extends true>(): T | undefined => undefined;
-
-// `create` returns its argument, typed as the tuple it was given.
-export const particle = Archetype.create([position, velocity]);
-expectType<Equal<typeof particle, readonly [typeof position, typeof velocity]>>();
-export const one: readonly Component.Key[] = particle;
-// A plain readonly list of components is an archetype too.
-export const plain = [position] as const;
-export const moveOver = System.create({ name: "archetypeTypeTest/moveOver", components: { write: plain } }, row => { row[position] += 1; });
-// @ts-expect-error a resource is never in an archetype
-Archetype.create([position, scale]);
-// @ts-expect-error nor is a string
-Archetype.create(["position"]);
-// Archetypes go wherever component lists do.
-export const move = System.create({ name: "archetypeTypeTest/move", components: { write: particle } }, row => { row[position] += row[velocity]; });
-export const read = System.create({ name: "archetypeTypeTest/read", observer: true, components: { read: particle } }, row => { void row[velocity]; });

package/src/interface/archetype/create.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Component } from "../component/component.js";
-import { archetypeIndexOf } from "../registry/index.js";
-import { Archetype } from "./archetype.js";
-
-const position = Symbol("archetypeCreateTest/position");
-const velocity = Symbol("archetypeCreateTest/velocity");
-declare module "@adobe/ecs" {
-    interface Components {
-        [position]: { type: number };
-        [velocity]: { type: number };
-    }
-}
-Component.register(position, { type: { type: "number" } });
-Component.register(velocity, { type: { type: "number" } });
-
-describe("Archetype.create", () => {
-    it("returns its argument, with a program-wide index of its own", () => {
-        const list = [position, velocity] as const;
-        const particle = Archetype.create(list);
-        const other = Archetype.create([velocity]);
-        expect(particle).toBe(list);
-        expect(particle).toEqual([position, velocity]);
-        expect(archetypeIndexOf(particle)).toBeGreaterThanOrEqual(0);
-        expect(archetypeIndexOf(other)).toBeGreaterThan(archetypeIndexOf(particle));
-        expect(Object.keys(particle)).toEqual(["0", "1"]);
-    });
-    it("keeps the index of a list given again", () => {
-        const particle = Archetype.create([position]);
-        const index = archetypeIndexOf(particle);
-        expect(Archetype.create(particle)).toBe(particle);
-        expect(archetypeIndexOf(particle)).toBe(index);
-    });
-    it("gives a plain list no index", () => {
-        expect(archetypeIndexOf([position])).toBe(-1);
-    });
-    it("throws for a component listed twice", () => {
-        expect(() => Archetype.create([position, velocity, position])).toThrow(`An archetype lists "archetypeCreateTest/position" twice.`);
-    });
-});

package/src/interface/archetype/create.ts

@@ -1,12 +0,0 @@
-import type { Component } from '../component/component.js';
-import { indexArchetype } from '../registry/archetypes.js';
-
-/**
- * Declares an archetype, the components an entity has, listed once each: returns `components`, typed as the tuple
- * given, with a program-wide index the world finds its storage by. It goes wherever a list of components does, as any
- * readonly list of components does. Throws for a component listed twice.
- */
-export const create = <const C extends readonly Component.Key[]>(components: C): C => {
-    indexArchetype(components);
-    return components;
-};

package/src/interface/archetype/index.ts

@@ -1 +0,0 @@
-export * from './create.js';

package/src/interface/archetype/values-of.ts

@@ -1,16 +0,0 @@
-import type { Component } from '../component/component.js';
-
-/** Components a spawn or add may leave out: a tag, whose value is `true`, and one whose type allows `null`, its start. */
-type Omissible<K extends Component.Key> = Component.Value<K> extends true ? K : null extends Component.Value<K> ? K : never;
-
-/**
- * The values a spawn or add of the components `C` takes, keyed by component and exact against `C`: a tag needs no
- * value, a component whose type allows `null` may be left out to start at `null`, and every other one is required.
- * Leaving one out, or giving `undefined`, never leaves the component out. A list that isn't a tuple takes any of its
- * components' values.
- */
-export type ValuesOf<C extends readonly Component.Key[]> = number extends C["length"]
-    // A list whose components aren't known until it runs, so any of them may be given.
-    ? { readonly [K in C[number]]?: Component.Value<K> }
-    : { readonly [K in C[number] as K extends Omissible<K> ? never : K]: Component.Value<K> }
-        & { readonly [K in C[number] as K extends Omissible<K> ? K : never]?: Component.Value<K> };