@adobe/ecs 0.1.0 → 0.2.1

package/dist/interface/system/commands.d.ts

@@ -1,19 +1,68 @@
 import type { Component } from '../component/component.js';
 import type { Entity } from '../entity/entity.js';
-import type { Essential } from '../component/value.js';
-import type { ValuesOf } from '../archetype/values-of.js';
+import type { Essential, Shared } from '../component/value.js';
+import type { ValuesOf } from './values-of.js';
 /** The value an `add` of one component takes: none for a tag. */
-type ValueArgument<K extends Essential> = Component.Value<K> extends true ? [value?: true] : [value: Component.Value<K>];
+type ValueArgument<K extends Essential> = Component<K> extends true ? [value?: true] : [value: Component<K>];
+/** Values of components of `C` a spawner's first call may give, constant for every entity it spawns. */
+type Preset<C extends readonly Essential[]> = {
+    readonly [K in C[number]]?: Component<K>;
+};
+/** The value of each shared component of `C`, which a spawner's first call must give, since they choose the archetype. */
+type SharedPreset<C extends readonly Essential[]> = {
+    readonly [K in C[number] & Shared]: Component<K>;
+};
+/**
+ * Whether `C` names a shared component, so a spawner of it takes its constants: a list that isn't a tuple, whose
+ * components aren't known until it runs, may take them or not.
+ */
+type RequiresPreset<C extends readonly Essential[]> = number extends C["length"] ? false : [C[number] & Shared] extends [never] ? false : true;
+/** A preset naming only components of `C`: any other key's value is a message naming it. Written in place, so keys print. */
+type Named<C extends readonly Essential[], P> = {
+    readonly [K in Exclude<keyof P, C[number]>]: {
+        readonly "error: a constant names a component of the spawn's list": {
+            readonly [Q in K]: "isn't one";
+        };
+    };
+};
+/**
+ * The list of a spawn, which, when it names a shared component and no constants are given, is a message naming them:
+ * the spawn takes their values first.
+ */
+type Spawned<C extends readonly Essential[], P> = RequiresPreset<C> extends true ? [keyof P] extends [never] ? C & {
+    readonly "error: a spawn of a shared component takes its value first, in its constants": {
+        readonly [K in C[number] & Shared]: Component<K>;
+    };
+} : C : C;
+/** Each component of `C` the constants `P` gave, whose value a spawn's values give again as a message naming it. */
+type Again<C extends readonly Essential[], P> = {
+    readonly [K in keyof P & C[number]]?: {
+        readonly "error: a spawn gives each component's value in one of its calls, this one in its constants": {
+            readonly [Q in K]: "given";
+        };
+    };
+};
+/**
+ * What a spawner with constants `P` of the components `C` takes: the rest of each entity's values, exactly, or nothing
+ * once none of them is required.
+ */
+type SpawnValues<C extends readonly Essential[], P> = number extends C["length"] ? [values: ValuesOf<C, keyof P>] : {} extends ValuesOf<C, keyof P> ? [values?: Rest<C, P>] : [values: Rest<C, P>];
+/** The values a spawner's call gives: the rest, and with constants, each component they gave as a message. */
+type Rest<C extends readonly Essential[], P> = [keyof P & C[number]] extends [never] ? ValuesOf<C, keyof P> : ValuesOf<C, keyof P> & Again<C, P>;
 /**
  * Structural changes and writes to other entities, applied in issue order at the next sync point. They take only the
  * components commands may add: every one but those rules derive.
  */
 export type Commands = {
     /**
-     * The spawner of entities of exactly `components`: the same function for a world and list each time, so calling
-     * it allocates nothing. It returns a real entity immediately, alive at the sync point.
+     * The spawner of entities of exactly `components`: on the world's thread, the same function for a world, list and
+     * equal constants each time while an archetype holds each shared value among them, so calling it allocates
+     * nothing; on a joined thread, the same for a list and one constants object, found by its identity. `constant` gives values every entity it spawns starts with: each shared
+     * component's, which the spawner must be given, since they choose the archetype, and any other's. Its call takes the
+     * rest, or nothing once none of them is required, each component's value from one of the two, never both, which
+     * fails the system; it returns a real entity immediately, alive at the sync point.
      */
-    spawn<const C extends readonly Essential[]>(components: C): (values: ValuesOf<C>) => Entity;
+    spawn<const C extends readonly Essential[], const P extends Preset<C> = {}>(components: Spawned<C, P>, ...constant: RequiresPreset<C> extends true ? [constant?: P & SharedPreset<C> & Named<C, P>] : [constant?: P & Named<C, P>]): (...values: SpawnValues<C, P>) => Entity;
     despawn(entity: Entity): void;
     /** Adds or replaces one component's value, marking it changed. */
     add<K extends Essential>(entity: Entity, component: K, ...value: ValueArgument<K>): void;

package/dist/interface/system/composite-declaration.d.ts

@@ -1,8 +1,6 @@
-import type { Name } from './name.js';
 import type { System } from './system.js';
 /** Each run passes every member the same input, with the fields of all their inputs. */
 export type CompositeDeclaration = {
-    readonly name?: Name;
     readonly systems: readonly System<unknown>[];
     /** Hard constraint, applied to every member. */
     readonly before?: readonly System<unknown>[];

package/dist/interface/system/create-resolved.d.ts

@@ -0,0 +1,9 @@
+import type { Resolved } from './declaration.js';
+import type { Leaf } from './leaf.js';
+import type { System } from './system.js';
+/**
+ * Makes a system of a declaration as the world takes it, with what its body reads and writes already listed: for the
+ * implementation's own systems, such as those standing for a joined thread's, whose bodies no build reads. Checks it
+ * as `System.create` does. Not part of the package's interface.
+ */
+export declare const createResolved: (declaration: Resolved, body: Leaf["body"], input?: unknown) => System<unknown>;

package/dist/interface/system/create-resolved.js

@@ -0,0 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { nameOf } from '../registry/items.js';
+import { claimSystem } from '../registry/program.js';
+import { checkLeaf, inputSchemaOf } from './check.js';
+/**
+ * Makes a system of a declaration as the world takes it, with what its body reads and writes already listed: for the
+ * implementation's own systems, such as those standing for a joined thread's, whose bodies no build reads. Checks it
+ * as `System.create` does. Not part of the package's interface.
+ */
+export const createResolved = (declaration, body, input) => {
+    const name = nameOf(declaration, undefined, "system");
+    const schema = inputSchemaOf(name, body, declaration.components === undefined ? 1 : 2, input);
+    const system = { kind: "system", name, declaration, input: schema, body };
+    checkLeaf(system);
+    claimSystem(system, undefined);
+    return system;
+};
+//# sourceMappingURL=create-resolved.js.map

package/dist/interface/system/create-resolved.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-resolved.js","sourceRoot":"","sources":["../../../src/interface/system/create-resolved.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAKtD;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,WAAqB,EAAE,IAAkB,EAAE,KAAe,EAAmB,EAAE;IAC1G,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IACtD,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAC9F,MAAM,MAAM,GAA2B,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAClG,SAAS,CAAC,MAAM,CAAC,CAAC;IAClB,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC/B,OAAO,MAAM,CAAC;AAClB,CAAC,CAAC"}

package/dist/interface/system/create.d.ts

@@ -1,92 +1,49 @@
-import type { Component } from '../component/component.js';
 import type { Entity } from '../entity/entity.js';
 import type { Index } from '../indexes/index-type.js';
-import type { Resource } from '../resource/resource.js';
-import type { Schema } from '../schema/schema.js';
-import type { Body } from './body.js';
-import type { Commands } from './commands.js';
+import type { Condition } from '../resource/condition.js';
+import type { Body, Context } from './body.js';
 import type { CompositeDeclaration } from './composite-declaration.js';
 import type { Declaration } from './declaration.js';
-import type { CheckMembers, CompositeInputOf, InputOf } from './input.js';
+import type { CheckMembers, CompositeInputOf, InputOf, ResultOf, ReturnsNoPromise } from './input.js';
 import type { Listed, Property } from './property.js';
-import type { StructComponent, StructResource } from './struct.js';
 import type { System } from './system.js';
 import type { OneThread, ThreadedBy, ThreadsOf } from './threads.js';
 import type { HeldBy } from './values.js';
-type Reduced<D extends Declaration> = keyof Property<D, "reduce"> & Resource.Key;
-type Written<D, K extends "components" | "resources"> = Listed<Property<D, K>, "write">;
-type Is<D> = Listed<Property<D, "resources">, "is">;
+import type { Shared } from '../component/value.js';
 type Lookups<D> = Property<D, "lookup">;
-/**
- * An index lookup reads and watches only what every entity its index holds has, and its system doesn't write what it
- * finds rows by or reads through it. A lookup by entity watches only what it reads or has.
- */
-type IndexLookups<D> = {
+/** A lookup's `changed` names what it requires: a lookup by entity's `with`, an index lookup's what its index holds. */
+type LookupChanges<D> = {
     readonly lookup?: {
         readonly [N in keyof Lookups<D>]?: Lookups<D>[N] extends {
             readonly index: Index<infer I>;
         } ? {
-            readonly index?: Index<{
-                readonly key: readonly Exclude<Component.Key, Written<D, "components">>[];
-            }>;
-            readonly read?: readonly Exclude<HeldBy<I>, Written<D, "components">>[];
             readonly changed?: readonly HeldBy<I>[] | true;
         } : {
-            readonly changed?: readonly (Listed<Lookups<D>[N], "read"> | Listed<Lookups<D>[N], "has">)[];
+            readonly changed?: readonly Listed<Lookups<D>[N], "with">[];
         };
     };
 };
-/** A system's rows are ordered by an index whose key parts it doesn't write. */
-type Order<D> = {
-    readonly order?: Index<{
-        readonly key: readonly Exclude<Component.Key, Written<D, "components">>[];
-    }>;
-};
-/**
- * A key in `write` is readable too, so it isn't also in `read`. A system doesn't read or filter on what it reduces
- * into, since the fold is only finished after every contributor runs. A condition in `is` is readable too, and isn't
- * written or also in `not`.
- */
-type Lists<D extends Declaration> = {
+/** What a body reads, writes and reduces into is inferred, never declared. */
+type Inferred = {
     readonly components?: {
-        readonly read?: readonly Exclude<Component.Key, Written<D, "components">>[];
+        readonly read?: never;
+        readonly write?: never;
+        readonly has?: never;
     };
     readonly resources?: {
-        readonly read?: readonly Exclude<Resource.Key, Written<D, "resources"> | Reduced<D> | Is<D>>[];
-        readonly write?: readonly Exclude<Resource.Key, Is<D>>[];
-        readonly changed?: readonly Exclude<Resource.Key, Reduced<D>>[];
-        readonly not?: readonly Exclude<Resource.Key, Is<D>>[];
-    };
-};
-type Kernel = {
-    readonly components?: {
-        readonly read?: readonly StructComponent[];
-        readonly write?: readonly StructComponent[];
-    };
-    readonly lookup?: {
-        readonly [name: string]: {
-            readonly read?: readonly StructComponent[];
-            readonly has?: readonly Component.Key[];
-            readonly not?: readonly Component.Key[];
-            readonly changed?: readonly Component.Key[];
-            readonly index?: never;
-        } | {
-            readonly read?: readonly StructComponent[];
-            readonly changed?: readonly Component.Key[] | true;
-            readonly index: Index<{
-                readonly key: readonly StructComponent[];
-            }>;
-        };
+        readonly read?: never;
+        readonly write?: never;
+        readonly reduce?: never;
     };
     readonly up?: {
-        readonly read?: readonly StructComponent[];
+        readonly read?: never;
     };
-    readonly order?: Index<{
-        readonly key: readonly StructComponent[];
-    }>;
+    readonly reduce?: never;
+};
+/** A condition is in `is` or `not`, not both. */
+type Conditions<D> = {
     readonly resources?: {
-        readonly read?: readonly StructResource[];
-        readonly write?: never;
+        readonly not?: readonly Exclude<Condition, Listed<Property<D, "resources">, "is">>[];
     };
 };
 /** What a GPU kernel can't use yet, beyond any kernel's limits. */
@@ -101,54 +58,59 @@ type GpuKernel = {
     readonly resources?: {
         readonly changed?: never;
     };
-    readonly reduce?: {
-        readonly [K in Resource.Key]?: never;
-    };
     readonly order?: {
         readonly "error: GPU kernels have no order yet": true;
     };
 };
 /**
- * An observer system only reads, after a sync point: it writes and reduces into nothing, takes no input, isn't a
- * kernel, has no `up`, and is ordered with nothing.
+ * An observer system only reads, after a sync point: its row and resources are read-only, and it never compiles to a
+ * kernel, has no `up`, and is ordered with nothing. That it takes no input is checked at its body.
  */
 type Observer = {
-    readonly kernel?: never;
-    readonly components?: {
-        readonly write?: never;
-    };
-    readonly resources?: {
-        readonly write?: never;
-    };
-    readonly reduce?: never;
-    readonly input?: never;
+    readonly kernel?: false;
     readonly up?: never;
     readonly before?: never;
     readonly after?: never;
     readonly during?: never;
 };
-/** The fields of input `I` that hold an entity. */
-type EntityFields<I> = {
-    [K in keyof I]-?: [Exclude<I[K], undefined>] extends [Entity] ? K : never;
-}[keyof I] & string;
-/** A system on one entity takes it from an entity field of its input, and runs on its row, in no order. */
-type Targeted<D extends Declaration> = {
-    readonly target?: EntityFields<InputOf<D>>;
-    readonly kernel?: never;
+/** A system on one entity runs on its row, in no order; that its target is an entity field of its input is checked at its body. */
+type Targeted = {
+    readonly kernel?: false;
     readonly up?: never;
     readonly order?: never;
-    readonly reduce?: never;
 };
-type Validate<D extends Declaration> = Lists<D> & IndexLookups<D> & Order<D> & (D extends {
-    readonly input: Schema;
+/** `where` names only shared components, and keeps rows unordered across archetypes, so it's without `up`, `order` and a target. */
+type Where<D> = D extends {
+    readonly components: {
+        readonly where: infer W;
+    };
 } ? {
     readonly components?: {
-        readonly added?: never;
-        readonly changed?: never;
+        readonly where?: {
+            readonly [K in Exclude<keyof W, Shared>]: {
+                readonly "error: where names only shared components, which each archetype holds one value of": K;
+            };
+        };
     };
-} : {}) & (D extends {
-    readonly kernel: "cpu" | "gpu";
-} ? Kernel : {}) & (D extends {
+} & (D extends {
+    readonly up: object;
+} | {
+    readonly order: object;
+} | {
+    readonly target: string;
+} ? {
+    readonly components?: {
+        readonly where?: {
+            readonly "error: where can't be used with up, order or a target, which run rows across archetypes": true;
+        };
+    };
+} : {}) : {};
+/**
+ * Whether the threads a declaration's objects live on hold, once its type is known: never checked against the
+ * constraint itself, which TypeScript instantiates the parameter with while a predicate in `where` waits for its type.
+ */
+type Placed<D extends Declaration> = Declaration extends D ? {} : OneThread<ThreadsOf<D>, ThreadedBy<D>>;
+type Validate<D extends Declaration> = LookupChanges<D> & Where<D> & Conditions<D> & Inferred & (D extends {
     readonly kernel: "gpu";
 } ? GpuKernel : {}) & (Property<D, "components"> extends undefined ? {
     readonly up?: {
@@ -157,17 +119,28 @@ type Validate<D extends Declaration> = Lists<D> & IndexLookups<D> & Order<D> & (
     readonly order?: {
         readonly "error: a system without components runs once, in no order": true;
     };
+    readonly kernel?: false | {
+        readonly "error: a system without components runs once, so there's nothing to compile": true;
+    };
 } : {}) & (D extends {
     readonly up: object;
 } ? {
     readonly order?: {
         readonly "error: up and order both decide the order of its rows": true;
     };
+} : {}) & (D extends {
+    readonly components: {
+        readonly optional: readonly [unknown, ...unknown[]];
+    };
+} ? {
+    readonly kernel?: boolean | {
+        readonly "error: a GPU kernel can't have optional components yet": true;
+    };
 } : {}) & (D extends {
     readonly observer: true;
 } ? Observer : {}) & (D extends {
     readonly target: string;
-} ? Targeted<D> : {}) & (D extends {
+} ? Targeted : {}) & (D extends {
     readonly target: string;
 } ? Property<D, "components"> extends undefined ? {
     readonly target?: {
@@ -175,38 +148,71 @@ type Validate<D extends Declaration> = Lists<D> & IndexLookups<D> & Order<D> & (
     };
 } : {} : {}) & {
     readonly shader?: never;
+    readonly input?: never;
 };
-/** The body of a system that declares nothing, which runs once per run with its commands. */
-type Alone = (context: {
-    readonly commands: Commands;
-}) => void;
+/** The fields of input `I` that hold an entity. */
+type EntityFields<I> = {
+    [K in keyof I]-?: [Exclude<I[K], undefined>] extends [Entity] ? K : never;
+}[keyof I] & string;
+/**
+ * What a declaration requires of the input its body takes, checked at the body, since the input is known only once the
+ * body is: a target names an entity field of it, and a system with input doesn't filter on added or changed, as its
+ * runs pass different input, nor is it an observer. Every check passes for `never`, the input before the body is
+ * inferred.
+ */
+type Checks<D, I> = [I] extends [never] ? unknown : (D extends {
+    readonly target: infer T extends string;
+} ? [I] extends [undefined] ? {
+    readonly "error: a system with a target takes its input after its context": T;
+} : T extends EntityFields<I> ? unknown : {
+    readonly "error: its target is no entity field of its input": T;
+} : unknown) & ([I] extends [undefined] ? unknown : (D extends {
+    readonly components: {
+        readonly added: object;
+    } | {
+        readonly changed: object;
+    };
+} ? {
+    readonly "error: a system with input can't filter on added or changed, as its runs pass different input; pass it through a resource": true;
+} : unknown) & (D extends {
+    readonly observer: true;
+} ? {
+    readonly "error: an observer system takes no input": true;
+} : unknown));
+/** The body of a system that declares nothing, which runs once per run with its resources and commands. */
+type Alone = (context: Context<{}>) => void;
 /** A composite: its list of members, or its declaration. */
 type Composition = readonly System<unknown>[] | CompositeDeclaration;
 /** A composite's members. */
 type MembersOf<C> = C extends CompositeDeclaration ? C["systems"] : C;
 /** A member whose input has a field of a different type than another member's becomes the error saying so. */
-type Checked<C> = C extends Alone ? unknown : C extends CompositeDeclaration ? {
+type Checked<C> = C extends Alone ? ReturnsNoPromise<C> : C extends CompositeDeclaration ? {
     readonly systems: CheckMembers<C["systems"]>;
 } : CheckMembers<C>;
 /**
  * Declares a system and returns it; nothing runs. The arguments tell the forms apart:
- * - `create(body)`: a system that declares nothing, whose body runs once per run with its commands.
+ * - `create(body)`: a system that declares nothing, whose body runs once per run with its resources and commands.
  * - `create(declaration, body)`: a system.
  * - `create([move, collide])`: a composite of the systems listed, which may live on different threads.
- * - `create({ systems: [move, collide], after: [input] })`: a composite with a name or constraints.
+ * - `create({ systems: [move, collide], after: [input] })`: a composite with constraints.
  *
- * Each run passes a composite's members one input, with every field of theirs. Throws if a system names a key that
- * isn't registered as its kind, lists a key in both `read` and `write`, writes a reference, a lookup reads a component
- * it writes or goes through an index keyed by one, or reads through an index what not every entity it holds has, its
+ * What a body reads, writes and reduces into the build infers from it. Each run passes a composite's members one
+ * input, with every field of theirs. Throws if a system names a key that isn't registered as its kind, its body writes
+ * a reference, a lookup's rows are read where it writes them or it goes through an index keyed by what it writes, its
  * rows are ordered by an index it isn't sorted or keyed by what it writes, its object components and resources live on
  * different threads, or its reductions, conditions, `up`, `order` or placement can't hold, or it's an observer and
- * writes, reduces, takes input, is a kernel, has `up` or is ordered; or if a composite's member isn't a system a
- * constructor returned, or two members declare an input field with different schemas. A composite's observer members
- * run after its sync point, ordered with nothing.
+ * writes, reduces, takes input, is a kernel, has `up` or is ordered; if the build couldn't follow how its body uses its
+ * resources, lookups or parent; or if a composite's member isn't a system a constructor returned, or two members
+ * declare an input field with different schemas. A composite's observer members run after its sync point, ordered
+ * with nothing.
+ *
+ * A run of a system without components resolves to what its body returns, or `undefined` when its conditions, resource
+ * change filters or index lookups' `changed: true` skip it; a run of any other system or a composite to nothing. A
+ * body returns no promise, by type and at runtime, where returning one fails its system: a run never waits for one.
  *
  * One argument, a body or a composite, is one overload, so a mistake in it is reported where it is rather than as no
  * overload matching.
  */
-export declare function create<const D extends Declaration>(declaration: D & Validate<D> & OneThread<ThreadsOf<D>, ThreadedBy<D>>, body: Body<D>): System<InputOf<D>>;
-export declare function create<const C extends Alone | Composition>(only: C & Checked<C>): C extends Alone ? System : System<CompositeInputOf<MembersOf<C>>>;
+export declare function create<const D extends Declaration, B extends Body<D, never>>(declaration: D & Validate<D> & Placed<D>, body: B & Checks<D, InputOf<D, B>> & ReturnsNoPromise<B>): System<InputOf<D, B>, ResultOf<D, B>>;
+export declare function create<const C extends Alone | Composition>(only: C & Checked<C>): C extends (context: Context<{}>) => infer R ? System<undefined, R> : System<CompositeInputOf<MembersOf<C>>>;
 export {};

package/dist/interface/system/create.js

@@ -1,27 +1,53 @@
 import { takeIdOfDeclaration } from '../registry/ids.js';
 import { nameOf } from '../registry/items.js';
 import { claimSystem } from '../registry/program.js';
-import { checkComposite, checkLeaf } from './check.js';
-export function create(first, second) {
+import { checkComposite, checkLeaf, inputSchemaOf } from './check.js';
+import { accessOf, compact, componentLists, lookupsLists, resourceUses, upReads, whereReadsOf } from './resolve.js';
+// The plugin passes the schema of the body's input as a third argument.
+export function create(first, second, input) {
     // The plugin gives its id to the call's first argument: the declaration, the members, or the body made into a
     // system alone.
     const id = takeIdOfDeclaration(first);
     if (isList(first))
-        return compose({ systems: first }, id);
+        return compose(first, { systems: first }, id);
     if (typeof first !== "function" && second === undefined && "systems" in first)
-        return compose(first, id);
-    const declaration = typeof first === "function" ? {} : first;
+        return compose(first, first, id);
+    const declared = typeof first === "function" ? {} : first;
     const body = typeof first === "function" ? first : second;
     if (body === undefined)
         throw new Error("A system needs a body, and a composite its systems.");
-    const system = { kind: "system", name: nameOf(declaration.name, id, "system"), declaration, body };
+    const name = nameOf(first, id, "system");
+    const declaration = resolve(`System "${name}"`, declared, accessOf(`System "${name}"`, first));
+    const schema = inputSchemaOf(name, body, declaration.components === undefined ? 1 : 2, input);
+    const system = { kind: "system", name, declaration, input: schema, body };
     checkLeaf(system);
     claimSystem(system, id);
     return system;
 }
+/** A declaration as the world takes it, with what the build inferred its body uses. */
+const resolve = (what, declared, access) => {
+    const reading = declared.observer === true;
+    const { components, lookup, up, resources, ...rest } = declared;
+    const uses = resourceUses(what, access, resources?.is);
+    // What `where`'s predicates read counts as the system's reads, for its order, conflicts and placement.
+    const whereReads = whereReadsOf(what, components, access);
+    const conditions = resources?.is ?? [];
+    for (const key of whereReads)
+        if (!uses.read.includes(key) && !uses.write.includes(key) && !conditions.includes(key))
+            uses.read.push(key);
+    const resolved = {
+        ...rest,
+        ...components === undefined ? {} : { components: componentLists(components, access.components, reading, whereReads) },
+        ...lookup === undefined ? {} : { lookup: lookupsLists(lookup, access) },
+        ...up === undefined ? {} : { up: { through: up.through, read: upReads(what, access) } },
+    };
+    const lists = compact({ read: uses.read, write: uses.write, reduce: uses.reduce, changed: resources?.changed, is: resources?.is, not: resources?.not });
+    return Object.keys(lists).length === 0 ? resolved : { ...resolved, resources: lists };
+};
 const isList = (value) => Array.isArray(value);
-const compose = (declaration, id) => {
-    const system = { kind: "composite", name: nameOf(declaration.name, id, "system"), declaration };
+/** A composite of `declaration`, labeled by `first`, the argument the plugin labeled. */
+const compose = (first, declaration, id) => {
+    const system = { kind: "composite", name: nameOf(first, id, "system"), declaration };
     checkComposite(system);
     claimSystem(system, id);
     return system;

package/dist/interface/system/create.js.map

@@ -1 +1 @@
-{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../src/interface/system/create.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAKrD,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAoJvD,MAAM,UAAU,MAAM,CAAC,KAAqF,EAAE,MAAqB;IAC/H,8GAA8G;IAC9G,gBAAgB;IAChB,MAAM,EAAE,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACtC,IAAI,MAAM,CAAC,KAAK,CAAC;QAAE,OAAO,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;IAC1D,IAAI,OAAO,KAAK,KAAK,UAAU,IAAI,MAAM,KAAK,SAAS,IAAI,SAAS,IAAI,KAAK;QAAE,OAAO,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACzG,MAAM,WAAW,GAAgB,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IAC1E,MAAM,IAAI,GAAG,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;IAC1D,IAAI,IAAI,KAAK,SAAS;QAAE,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IAC/F,MAAM,MAAM,GAA2B,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;IAC3H,SAAS,CAAC,MAAM,CAAC,CAAC;IAClB,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACxB,OAAO,MAAM,CAAC;AAClB,CAAC;AAED,MAAM,MAAM,GAAG,CAAC,KAAc,EAAuC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAE7F,MAAM,OAAO,GAAG,CAAC,WAAiC,EAAE,EAAsB,EAAmB,EAAE;IAC3F,MAAM,MAAM,GAAgC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IAC7H,cAAc,CAAC,MAAM,CAAC,CAAC;IACvB,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACxB,OAAO,MAAM,CAAC;AAClB,CAAC,CAAC"}
+{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../src/interface/system/create.ts"],"names":[],"mappings":"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"}

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

@@ -1,35 +1,38 @@
 import type { Index } from '../indexes/index-type.js';
-import type { Schema } from '../schema/schema.js';
-import type { ComponentAccess, ResourceAccess, SystemLookup, Up } from './access.js';
-import type { Name } from './name.js';
+import type { ComponentAccess, ComponentLists, ResourceAccess, ResourceLists, SystemLookup, SystemLookupLists, Up, UpLists } from './access.js';
 import type { Shader } from './render.js';
 import type { System } from './system.js';
-import type { OperatorOf, Reduced } from '../resource/reduction.js';
 /**
  * A system never declares its thread: it runs on the one its object components and resources live on, those it
- * reads, writes or filters on by change, through `components`, `lookup`, `up` and `resources` but `has` and `not`.
- * Without them, a kernel runs on the kernel pool and any other system on `"world"`.
+ * reads, writes or filters on by change, through its row, lookups, `up` and resources. Without them, a kernel runs on
+ * the kernel pool and any other system on `"world"`. A declaration says only what its body can't show: which entities
+ * it runs over, its filters and conditions, and its order; the build infers what the body reads, writes and reduces.
  */
 export type Declaration = {
-    readonly name?: Name;
     /**
-     * Compiled to a kernel, which the build rejects if the body leaves the kernel subset. Values in `components` and
-     * `lookup` must be structs and resources read-only. Without it, the system runs as written, on its thread.
-     * - `"cpu"`: runs on the kernel pool. - `"gpu"`: also has no lookups, change filters, commands or loops, and only
-     *   4-byte scalar values, its `up` included. It runs as a   compute shader in a world with a GPU, and as a `"cpu"`
-     *   kernel in one without. Every matched row counts as   changed in what it writes.
+     * Whether its body compiles to a kernel, a function the build compiles to run on every matched row, in parallel, on
+     * the kernel pool. Values in `components` and `lookup` must be structs and resources read-only.
+     * - Without it, a system with components compiles when its body is in the kernel subset and its declaration allows
+     *   it, and otherwise runs as written, computing as the body as written does. A system without components runs once,
+     *   as written.
+     * - `true`: compiles, or the build fails saying why. Its arithmetic may round each step to storage precision, as
+     *   WASM's f32 SIMD lanes do, so its results may differ from the body as written.
+     * - `false`: runs as written, on its thread.
+     * - `"gpu"`: also has no lookups, change filters, commands or loops, and only 4-byte scalar values, its `up`
+     *   included. It runs as a compute shader in a world with a GPU, and as a kernel on the pool in one without. Every
+     *   matched row counts as changed in what it writes.
      */
-    readonly kernel?: "cpu" | "gpu";
-    /** The entities it runs over, and what it reads and writes of theirs. Omitted for a system that runs once per run. */
+    readonly kernel?: boolean | "gpu";
+    /** The entities it runs over. Omitted for a system that runs once per run. */
     readonly components?: ComponentAccess;
     readonly lookup?: {
         readonly [name: string]: SystemLookup;
     };
     /**
-     * Runs rows in depth order through `through`, so each reads its parent's `read` values after the parent ran, as
-     * the context's `up`, or null for a row without a parent. With change filters, a row also passes when its parent,
-     * or what it reads of its parent, changed since the system last ran, or it moved to another archetype, as removing
-     * its parent moves it. Rows on or under a parent cycle don't run.
+     * Runs rows in depth order through `through`, so each reads its parent's values after the parent ran, as the
+     * context's `up`, or null for a row without a parent. With change filters, a row also passes when its parent, or
+     * what it reads of its parent, changed since the system last ran, or it moved to another archetype, as removing its
+     * parent moves it. Rows on or under a parent cycle don't run.
      */
     readonly up?: Up;
     /**
@@ -41,18 +44,10 @@ export type Declaration = {
         readonly sorted: true;
     }>;
     readonly resources?: ResourceAccess;
-    /** The resources its body contributes to, each with the operator its `reduce` trait declares. */
-    readonly reduce?: {
-        readonly [K in Reduced]?: OperatorOf<K>;
-    };
-    /** The object of named fields passed to each run. A system with input can't use `added` or `changed`. */
-    readonly input?: Extract<Schema, {
-        readonly type: "object";
-    }>;
     /**
-     * The input field naming the one entity it runs on: its body runs once, on that entity's row, when the entity is
-     * alive and matches `components`, and not at all otherwise. Needs `components`; not with `kernel`, `up`, `order`
-     * or `reduce`.
+     * The field of its body's input naming the one entity it runs on: its body runs once, on that entity's row, when
+     * the entity is alive and matches `components`, and not at all otherwise. Needs `components`; not with `kernel`,
+     * `up` or `order`, nor with a body that reduces.
      */
     readonly target?: string;
     /** Makes this a render system (see `render`): its body records GPU work over the GPU copy of the components it names. */
@@ -69,3 +64,12 @@ export type Declaration = {
      */
     readonly observer?: true;
 };
+/** A declaration as the world takes it: the build's inferred reads, writes and reductions joined with what it declares. */
+export type Resolved = Omit<Declaration, "components" | "lookup" | "up" | "resources"> & {
+    readonly components?: ComponentLists;
+    readonly lookup?: {
+        readonly [name: string]: SystemLookupLists;
+    };
+    readonly up?: UpLists;
+    readonly resources?: ResourceLists;
+};

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interface/system/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,MAAM,EAAwC,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interface/system/index.ts"],"names":[],"mappings":"AAEA,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,MAAM,EAAwC,MAAM,aAAa,CAAC"}