@adobe/ecs 0.1.0 → 0.2.1

package/dist/interface/report/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interface/report/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAEtC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAG9C,oHAAoH;AACpH,MAAM,CAAC,MAAM,SAAS,GAAG,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC"}

package/dist/interface/report/report.d.ts

@@ -1,12 +0,0 @@
-import type { Component } from '../component/component.js';
-import type { errors, run } from './components.js';
-/**
- * A report's values, as rows and lookups give them. After the sync point of each run and tick, before its observer
- * systems, the world writes its report, an entity it keeps for recent runs: `errors` is there only when something went
- * wrong. Once a run resolves, its report is there. Queries that require no component don't see reports.
- */
-export type Report = {
-    readonly [run]: Component.Value<typeof run>;
-    readonly [errors]?: Component.Value<typeof errors>;
-};
-export * as Report from './index.js';

package/dist/interface/report/report.js

@@ -1,2 +0,0 @@
-export * as Report from './index.js';
-//# sourceMappingURL=report.js.map

package/dist/interface/report/report.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"report.js","sourceRoot":"","sources":["../../../src/interface/report/report.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,MAAM,MAAM,YAAY,CAAC"}

package/dist/interface/resource/declaration.d.ts

@@ -1,31 +0,0 @@
-import type { Describing, Starting } from "../component/declaration.js";
-import type { IsData } from "../schema/is-data.js";
-import type { Schema } from "../schema/schema.js";
-import type { Key as TraitKey } from "../trait/key.js";
-import type { Required } from "../trait/required.js";
-import type { Traits } from "../trait/types.js";
-import type { SymbolKeys } from "../trait/symbol-keys.js";
-import type { Key } from "./key.js";
-import type { Resources } from "./types.js";
-/**
- * A resource always has a value: its schema's `default` or the declaration's, of the declared type `T`, either left
- * out only when `T` allows `null`. A type that isn't data has no schema, so only the declaration's.
- */
-type TypePart<S, T> = IsData<T> extends true ? [S] extends [never] ? {
-    readonly type: Schema;
-} : Describing<S, T> & (S extends {
-    readonly default: unknown;
-} ? {
-    readonly default?: never;
-} : Starting<T>) : {
-    readonly type?: never;
-} & Starting<T>;
-/** As for components, with the value a resource starts at. */
-export type Declaration<K extends Key, S> = {
-    readonly type?: S;
-} & TypePart<S, Resources[K]["type"]> & {
-    readonly [T in Exclude<keyof Resources[K], "type">]: T extends TraitKey ? (Resources[K][T] extends Traits<K>[T] ? Resources[K][T] : never) : never;
-} & {
-    readonly [T in Exclude<TraitKey, keyof Resources[K]>]?: never;
-} & Required<Resources[K], Resources[K]["type"]> & SymbolKeys;
-export {};

package/dist/interface/resource/declaration.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=declaration.js.map

package/dist/interface/resource/declaration.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"declaration.js","sourceRoot":"","sources":["../../../src/interface/resource/declaration.ts"],"names":[],"mappings":""}

package/dist/interface/resource/register.d.ts

@@ -1,13 +0,0 @@
-import type { Component } from "../component/component.js";
-import type { Schema } from "../schema/schema.js";
-import type { Key as TraitKey } from "../trait/key.js";
-import type { Declaration } from "./declaration.js";
-import type { Key } from "./key.js";
-/**
- * Registers the resource `key`, a plain `Symbol(...)` whose traits `Resources` declares, as `Component.register`
- * does: `Resource.register(gravity, { type: { type: "number", default: -9.8 } })`. A resource always has a value: its
- * schema's `default` or the declaration's, either left out only when its type allows `null`, which it then starts at.
- */
-export declare function register<K extends Exclude<Key, Component.Key | TraitKey> & symbol, const S extends Schema & {
-    readonly default?: unknown;
-} = never>(key: K, declaration: Declaration<K, S>): void;

package/dist/interface/resource/register.js

@@ -1,6 +0,0 @@
-import { createRegistry } from "../registry/declarations.js";
-const registry = createRegistry("resource");
-export function register(key, declaration) {
-    registry(key, declaration);
-}
-//# sourceMappingURL=register.js.map

package/dist/interface/resource/register.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"register.js","sourceRoot":"","sources":["../../../src/interface/resource/register.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAuB,MAAM,6BAA6B,CAAC;AAMlF,MAAM,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC;AAQ5C,MAAM,UAAU,QAAQ,CAAC,GAAY,EAAE,WAA2B;IAC9D,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;AAC/B,CAAC"}

package/dist/interface/rule/name.d.ts

@@ -1,6 +0,0 @@
-/**
- * The label reports and errors give it, which needn't be unique: the value its constructor returns is its identity, so
- * separately written code can't collide by name. Namespacing it (`"physics/integrate"`) keeps labels short. Without
- * one, it's labeled by its binding and the id the plugin gave it, or else by its kind numbered.
- */
-export type Name = string;

package/dist/interface/rule/name.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=name.js.map

package/dist/interface/rule/name.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"name.js","sourceRoot":"","sources":["../../../src/interface/rule/name.ts"],"names":[],"mappings":""}

package/dist/interface/schema/is-data.d.ts

@@ -1,19 +0,0 @@
-type Method = (...parameters: never[]) => unknown;
-/** How deep `NotData` looks into members: deeper ones count as data, so recursive types stay finite. */
-type Depth = [never, 0, 1, 2, 3, 4];
-/**
- * True for a value that isn't data: a function, an object with a member that isn't data, or a `Set` or `Map`, which
- * changes in place. A `ReadonlySet` or `ReadonlyMap` is data when what it holds is. Members are looked at five levels
- * deep.
- */
-type NotData<T, D extends number = 5> = [
-    D
-] extends [never] ? false : T extends string | number | boolean | bigint | symbol | null | undefined ? false : T extends Method ? true : T extends readonly (infer E)[] ? NotData<E, Depth[D]> : T extends ReadonlyMap<infer K, infer V> ? (T extends Map<K, V> ? true : NotData<K, Depth[D]> | NotData<V, Depth[D]>) : T extends ReadonlySet<infer E> ? (T extends Set<E> ? true : NotData<E, Depth[D]>) : T extends object ? (true extends {
-    [K in keyof T]-?: NotData<T[K], Depth[D]>;
-}[keyof T] ? true : false) : false;
-/**
- * Whether a declared type is data a schema describes, so its registration gives that schema. A `Blob`, an
- * `HTMLElement` or a `GPUDevice` isn't: its registration has no `type`, and the world stores the value as it is.
- */
-export type IsData<T> = true extends NotData<T> ? false : true;
-export {};

package/dist/interface/schema/is-data.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=is-data.js.map

package/dist/interface/schema/is-data.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-data.js","sourceRoot":"","sources":["../../../src/interface/schema/is-data.ts"],"names":[],"mappings":""}

package/dist/interface/trait/index.d.ts

@@ -1 +0,0 @@
-export { register } from './register.js';

package/dist/interface/trait/index.js

@@ -1,2 +0,0 @@
-export { register } from './register.js';
-//# sourceMappingURL=index.js.map

package/dist/interface/trait/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interface/trait/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC"}

package/dist/interface/trait/register.d.ts

@@ -1,7 +0,0 @@
-import type { BuiltIn, Key } from './key.js';
-/**
- * Registers a trait under `key`, a plain `Symbol(...)`: string trait names are the core's built-in traits. The same
- * trait again is accepted, and so is a new symbol with a trait's id, as a module evaluated again makes it. Throws for a key that isn't a plain symbol, or
- * one registered as a component or resource.
- */
-export declare const register: (key: Exclude<Key, BuiltIn> & symbol) => void;

package/dist/interface/trait/register.js

@@ -1,8 +0,0 @@
-import { addTrait } from '../registry/traits.js';
-/**
- * Registers a trait under `key`, a plain `Symbol(...)`: string trait names are the core's built-in traits. The same
- * trait again is accepted, and so is a new symbol with a trait's id, as a module evaluated again makes it. Throws for a key that isn't a plain symbol, or
- * one registered as a component or resource.
- */
-export const register = (key) => addTrait(key);
-//# sourceMappingURL=register.js.map

package/dist/interface/trait/register.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"register.js","sourceRoot":"","sources":["../../../src/interface/trait/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAmC,EAAQ,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC"}

package/dist/interface/trait/required.d.ts

@@ -1,10 +0,0 @@
-import type { IsNode } from '../platform/platform.js';
-/**
- * The traits a declaration must have beyond those it lists: a DOM `Node` lives on `"main"`, so a declaration of one
- * without `thread` can't be registered. Where the DOM library isn't loaded, nothing is required.
- */
-export type Required<Entry, T> = IsNode<T> extends true ? (Entry extends {
-    readonly thread: unknown;
-} ? {} : {
-    readonly thread: "main";
-}) : {};

package/dist/interface/trait/required.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=required.js.map

package/dist/interface/trait/required.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"required.js","sourceRoot":"","sources":["../../../src/interface/trait/required.ts"],"names":[],"mappings":""}

package/dist/interface/trait/symbol-keys.d.ts

@@ -1,16 +0,0 @@
-import type { Components } from '../component/types.js';
-import type { Resources } from '../resource/types.js';
-import type { BuiltIn } from './key.js';
-import type { Traits } from './types.js';
-/** A required property naming `problem` and the keys that cause it, or nothing without such keys. */
-type Problem<Keys, Text extends string> = [Keys] extends [never] ? {} : {
-    readonly [P in Text]: Keys;
-};
-/**
- * What every declaration also requires while `C`, `R` or `T` has a key that isn't a symbol, besides the built-in
- * traits: a property named for the problem, holding the keys, so registration fails to compile and says why.
- */
-export type KeysMustBeSymbols<C, R, T> = Problem<Exclude<keyof C, symbol>, "component keys must be symbols"> & Problem<Exclude<keyof R, symbol>, "resource keys must be symbols"> & Problem<Exclude<keyof T, symbol | BuiltIn>, "trait keys must be symbols">;
-/** `KeysMustBeSymbols` of the program's components, resources and traits, computed once. */
-export type SymbolKeys = KeysMustBeSymbols<Components, Resources, Traits<never>>;
-export {};

package/dist/interface/trait/symbol-keys.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=symbol-keys.js.map

package/dist/interface/trait/symbol-keys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"symbol-keys.js","sourceRoot":"","sources":["../../../src/interface/trait/symbol-keys.ts"],"names":[],"mappings":""}

package/dist/interface/trait/trait.d.ts

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

package/dist/interface/trait/trait.js

@@ -1,2 +0,0 @@
-export * as Trait from './index.js';
-//# sourceMappingURL=trait.js.map

package/dist/interface/trait/trait.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"trait.js","sourceRoot":"","sources":["../../../src/interface/trait/trait.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC"}

package/src/guide/01-resources.test.ts

@@ -1,44 +0,0 @@
-import { expect, it } from "vitest";
-import { Entity, Resource, System, World } from "../index.js";
-
-// A resource is a key whose value a world holds once.
-export const gravity = Symbol("gravity");
-export const names = Symbol("names");
-export const audio = Symbol("audio");
-export const focused = Symbol("focused");
-
-// Its traits are declared; `type` is the value's type.
-declare module "@adobe/ecs" {
-    interface Resources {
-        [gravity]: { type: number };
-        [names]: { type: ReadonlyMap<string, number> };
-        [audio]: { type: AudioContext | null };
-        [focused]: { type: Entity };
-    }
-}
-
-// Registration gives the same traits, with a schema that describes exactly the declared type. A resource always has a
-// value: its schema's default, or one beside it.
-Resource.register(gravity, { type: { type: "number", default: -9.8 } });
-Resource.register(names, { type: { type: "map", keys: { type: "string" }, values: { type: "number" } }, default: new Map() });
-// A value that isn't data has no schema and is stored as it is. A type that allows null starts there.
-Resource.register(audio, {});
-// No entity is Entity.none rather than null, so an entity stays data every thread reads.
-Resource.register(focused, { type: { ...Entity.schema, default: Entity.none } });
-
-// Systems read a world: an observer only reads, after the world's changes apply.
-let values: readonly unknown[] = [];
-const read = System.create({ observer: true, resources: { read: [gravity, names, audio, focused] } }, ({ resources }) => {
-    values = [resources[gravity], resources[names], resources[audio], resources[focused]];
-});
-
-it("holds one value per world", async () => {
-    // A world starts each resource at its default, or at the value given when it's created.
-    await using earth = World.create();
-    await using moon = World.create({ [gravity]: -1.6 });
-    // run: runs a system once.
-    await earth.run(read);
-    expect(values).toEqual([-9.8, new Map(), null, Entity.none]);
-    await moon.run(read);
-    expect(values[0]).toBe(-1.6);
-});

package/src/guide/02-entities.test.ts

@@ -1,57 +0,0 @@
-import { expect, it } from "vitest";
-import { Archetype, Component, System, Vec3, World } from "../index.js";
-
-// A component is a key whose values entities hold, declared and registered as a resource is.
-export const position = Symbol("position");
-export const velocity = Symbol("velocity");
-export const enemy = Symbol("enemy");
-
-declare module "@adobe/ecs" {
-    interface Components {
-        [position]: { type: Vec3 };
-        [velocity]: { type: Vec3 };
-        // A tag: present or not, with no value.
-        [enemy]: { type: true };
-    }
-}
-
-Component.register(position, { type: Vec3.schema });
-Component.register(velocity, { type: Vec3.schema });
-Component.register(enemy, { type: { const: true } });
-
-// An archetype names a list of components, once at module scope; it goes wherever a list of components does.
-export const Particle = Archetype.create([position, velocity]);
-
-// Systems spawn entities: name the components, then give their values.
-export const spawn = System.create(({ commands }) => {
-    commands.spawn([position, enemy])({ [position]: [0, 10, 0] });
-    commands.spawn(Particle)({ [position]: [0, 0, 0], [velocity]: [1, 0, 0] });
-});
-
-// Commands also add and remove components, and despawn entities.
-export const defeat = System.create({ components: { has: [enemy] } }, (row, { commands }) => {
-    commands.remove(row.entity, enemy);
-});
-
-// An observer system reads them back, once per entity with its components.
-const foes: Vec3[] = [];
-const readFoes = System.create({ observer: true, components: { read: [position], has: [enemy] } }, row => {
-    foes.push(row[position]);
-});
-let particles = 0;
-const countParticles = System.create({ observer: true, components: { has: Particle } }, () => {
-    particles += 1;
-});
-
-it("spawns entities with components", async () => {
-    await using world = World.create();
-    await world.run(spawn);
-    await world.run(readFoes);
-    await world.run(countParticles);
-    expect(foes).toEqual([[0, 10, 0]]);
-    expect(particles).toBe(1);
-    await world.run(defeat);
-    foes.length = 0;
-    await world.run(readFoes);
-    expect(foes).toEqual([]);
-});

package/src/guide/03-systems.test.ts

@@ -1,87 +0,0 @@
-import { expect, it } from "vitest";
-import { Component, Report, Resource, System, Vec3, World } from "../index.js";
-
-const position = Symbol("position");
-const velocity = Symbol("velocity");
-const frozen = Symbol("frozen");
-const delta = Symbol("delta");
-const frames = Symbol("frames");
-
-declare module "@adobe/ecs" {
-    interface Components {
-        [position]: { type: Vec3 };
-        [velocity]: { type: Vec3 };
-        [frozen]: { type: true };
-    }
-    interface Resources {
-        [delta]: { type: number };
-        [frames]: { type: number };
-    }
-}
-
-Component.register(position, { type: Vec3.schema });
-Component.register(velocity, { type: Vec3.schema });
-Component.register(frozen, { type: { const: true } });
-Resource.register(delta, { type: { type: "number", default: 0.5 } });
-Resource.register(frames, { type: { type: "number", default: 0 } });
-
-const spawn = System.create(({ commands }) => {
-    commands.spawn([position, velocity])({ [position]: [0, 0, 0], [velocity]: [2, 0, 0] });
-    commands.spawn([position, velocity, frozen])({ [position]: [0, 0, 0], [velocity]: [2, 0, 0] });
-});
-
-// Runs once per entity with every component in read and write, and none in not.
-const move = System.create({
-    // Optional: labels the system in reports.
-    name: "physics/move",
-    components: { read: [velocity], write: [position], not: [frozen] },
-    resources: { read: [delta] },
-}, (row, { resources }) => {
-    // Values are replaced whole, never edited in place.
-    row[position] = Vec3.add(row[position], Vec3.scale(row[velocity], resources[delta]));
-});
-
-// Without components, a system runs once per run.
-const count = System.create({ resources: { write: [frames] } }, ({ resources }) => {
-    resources[frames] += 1;
-});
-
-// An observer system reads what the runs before it left, and changes nothing: run one to read the world, or add one to
-// react to it.
-const moved: Vec3[] = [];
-let counted = 0;
-const read = System.create({ observer: true, components: { read: [position], not: [frozen] }, resources: { read: [frames] } }, (row, { resources }) => {
-    moved.push(row[position]);
-    counted = resources[frames];
-});
-
-it("runs a system once per entity, or once", async () => {
-    await using world = World.create();
-    // run: runs a system once.
-    await world.run(spawn);
-    await world.run(move);
-    await world.run(count);
-    await world.run(read);
-    expect(moved).toEqual([[1, 0, 0]]);
-    expect(counted).toBe(1);
-});
-
-const fail = System.create({ name: "fail" }, () => {
-    throw new Error("broken");
-});
-
-// A run resolves to its number. Every run and tick has a report, an entity: `Report.run` says what it ran and how long
-// it took, and `Report.errors` is there only when something went wrong. An observer system added to follow errors as
-// they change logs them; what observer systems throw is in the next run's report.
-const logged: string[] = [];
-const logFailures = System.create({ observer: true, components: { read: [Report.errors], changed: [Report.errors] } }, row => {
-    for (const failure of row[Report.errors].failures) logged.push(`${failure.name}: ${failure.message}`);
-});
-
-it("reports what failed as entities", async () => {
-    await using world = World.create();
-    world.add(logFailures);
-    const run: number = await world.run(fail);
-    expect(run).toBe(1);
-    expect(logged).toEqual(["fail: broken"]);
-});

package/src/guide/04-ticks.test.ts

@@ -1,73 +0,0 @@
-import { expect, it } from "vitest";
-import { always, cadence, clock, Resource, System, wake, World } from "../index.js";
-
-const elapsed = Symbol("elapsed");
-const steps = Symbol("steps");
-
-declare module "@adobe/ecs" {
-    interface Resources {
-        [elapsed]: { type: number };
-        [steps]: { type: number };
-    }
-}
-
-Resource.register(elapsed, { type: { type: "number", default: 0 } });
-Resource.register(steps, { type: { type: "number", default: 0 } });
-
-// clock is the current tick's: delta is the milliseconds since the last one.
-const advance = System.create({ resources: { read: [clock], write: [elapsed] } }, ({ resources }) => {
-    resources[elapsed] += resources[clock].delta;
-});
-
-// Added, an observer system reacts to changes: with elapsed in changed, it runs after each tick that changed it.
-let reached: (value: number) => void = () => {};
-const watch = System.create({ observer: true, resources: { read: [elapsed], changed: [elapsed] } }, ({ resources }) => {
-    if (resources[elapsed] >= 30) reached(resources[elapsed]);
-});
-
-let read = { elapsed: 0, delta: 0 };
-const readTime = System.create({ observer: true, resources: { read: [elapsed, clock] } }, ({ resources }) => {
-    read = { elapsed: resources[elapsed], delta: resources[clock].delta };
-});
-
-it("runs added systems on every tick", async () => {
-    // cadence ticks once per animation frame by default; fixed ticks every step milliseconds, each with that delta.
-    // A tick runs only after a run arrives, unless always is set.
-    await using world = World.create({ [cadence]: { kind: "fixed", step: 10 }, [always]: true });
-    const ticked = new Promise<number>(resolve => { reached = resolve; });
-    // add: runs a system on every tick.
-    world.add(advance);
-    world.add(watch);
-    expect(await ticked).toBeGreaterThanOrEqual(30);
-    await world.run(readTime);
-    expect(read.delta).toBe(10);
-    // remove: takes a system added off every tick again.
-    world.remove(advance);
-    await world.run(readTime);
-    const stopped = read.elapsed;
-    await new Promise(resolve => setTimeout(resolve, 50));
-    await world.run(readTime);
-    expect(read.elapsed).toBe(stopped);
-});
-
-// A system asks for another tick by contributing a time to wake: the first tick at or after it runs. Work that a tick's
-// commands start and a later tick finishes asks for the next one this way.
-const step = System.create({ resources: { read: [clock], write: [steps] }, reduce: { [wake]: "min" } }, ({ resources, reduce }) => {
-    resources[steps] += 1;
-    if (resources[steps] < 3) reduce[wake](resources[clock].now);
-});
-
-let finished: (value: number) => void = () => {};
-const watchSteps = System.create({ observer: true, resources: { read: [steps], changed: [steps] } }, ({ resources }) => {
-    if (resources[steps] === 3) finished(resources[steps]);
-});
-
-it("ticks again when a system asks", async () => {
-    await using world = World.create({ [cadence]: { kind: "fixed", step: 10 } });
-    const done = new Promise<number>(resolve => { finished = resolve; });
-    world.add(step);
-    world.add(watchSteps);
-    // One run arriving ticks once; step's wakes tick twice more.
-    await world.run(System.create(() => {}));
-    expect(await done).toBe(3);
-});

package/src/guide/05-scheduling.test.ts

@@ -1,60 +0,0 @@
-import { expect, it } from "vitest";
-import { Component, System, World } from "../index.js";
-
-const health = Symbol("health");
-const damage = Symbol("damage");
-
-declare module "@adobe/ecs" {
-    interface Components {
-        [health]: { type: number };
-        [damage]: { type: number };
-    }
-}
-
-Component.register(health, { type: { type: "number" } });
-Component.register(damage, { type: { type: "number" } });
-
-const spawn = System.create(({ commands }) => { commands.spawn([health, damage])({ [health]: 10, [damage]: 4 }); });
-const hit = System.create({ components: { read: [damage], write: [health] } }, row => {
-    row[health] -= row[damage];
-});
-// before, after and during list the systems themselves.
-const heal = System.create({ components: { write: [health] }, after: [hit] }, row => {
-    row[health] = Math.min(row[health] * 2, 10);
-});
-// A list of systems is a composite: it runs its members as one system, in their order; members without an order
-// between them may run in parallel. { systems, after, ... } declares one with a name or constraints.
-const frame = System.create([heal, hit]);
-
-const healths: number[] = [];
-const read = System.create({ observer: true, components: { read: [health] } }, row => {
-    healths.push(row[health]);
-});
-
-it("orders a composite's members by their constraints", async () => {
-    await using world = World.create();
-    await world.run(spawn);
-    await world.run(frame);
-    await world.run(read);
-    // hit, 10 - 4 = 6, then heal, min(12, 10).
-    expect(healths).toEqual([10]);
-});
-
-// Phases are systems that do nothing; a system during one runs after what the phase follows and before what follows it.
-const update = System.create(() => {});
-const render = System.create({ after: [update] }, () => {});
-const poison = System.create({ components: { write: [health] }, during: [update] }, row => {
-    row[health] -= 1;
-});
-const seen: number[] = [];
-const report = System.create({ components: { read: [health] }, during: [render] }, row => {
-    seen.push(row[health]);
-});
-const phased = System.create([report, poison, update, render]);
-
-it("orders systems during phases by the order of the phases", async () => {
-    await using world = World.create();
-    await world.run(spawn);
-    await world.run(phased);
-    expect(seen).toEqual([9]);
-});

package/src/guide/06-sync-points.test.ts

@@ -1,59 +0,0 @@
-import { expect, it } from "vitest";
-import { Component, Resource, System, World } from "../index.js";
-
-const health = Symbol("health");
-const seen = Symbol("seen");
-
-declare module "@adobe/ecs" {
-    interface Components {
-        [health]: { type: number };
-    }
-    interface Resources {
-        [seen]: { type: number };
-    }
-}
-
-Component.register(health, { type: { type: "number" } });
-Resource.register(seen, { type: { type: "number", default: 0 } });
-
-// Value writes apply at once; commands wait for the sync point that ends each run, then apply in the order issued.
-const spawn = System.create(({ commands }) => {
-    // spawn gives the entity at once, so later commands can name it.
-    const hero = commands.spawn([health])({ [health]: 3 });
-    commands.add(hero, health, 5);
-    // Spawned and despawned before the sync point, it never exists.
-    commands.despawn(commands.spawn([health])({ [health]: 1 }));
-});
-// A composite is one run with one sync point: count runs after spawn, before its entities exist.
-const count = System.create({ components: { has: [health] }, resources: { write: [seen] }, after: [spawn] }, (row, { resources }) => {
-    resources[seen] += 1;
-});
-const frame = System.create([spawn, count]);
-
-const healths: number[] = [];
-// An observer runs after the sync point of every run and tick it's added to, reading what it left; it writes nothing.
-const watch = System.create({ observer: true, components: { read: [health] } }, row => {
-    healths.push(row[health]);
-});
-let counted = 0;
-const readSeen = System.create({ observer: true, resources: { read: [seen] } }, ({ resources }) => {
-    counted = resources[seen];
-});
-
-it("applies commands at the sync point that ends each run", async () => {
-    await using world = World.create();
-    await world.run(frame);
-    await world.run(readSeen);
-    expect(counted).toBe(0);
-    await world.run(count);
-    await world.run(readSeen);
-    expect(counted).toBe(1);
-});
-
-it("runs observer systems after each sync point", async () => {
-    healths.length = 0;
-    await using world = World.create();
-    world.add(watch);
-    await world.run(spawn);
-    expect(healths).toEqual([5]);
-});