@adobe/ecs 0.1.0 → 0.2.1

package/src/interface/system/body.ts

@@ -1,49 +1,79 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Component } from '../component/component.js';
+import type { Writable } from '../component/value.js';
 import type { Entity } from '../entity/entity.js';
 import type { Resource } from '../resource/resource.js';
 import type { Holding } from '../resource/condition.js';
-import type { Schema } from '../schema/schema.js';
+import type { Reduced } from '../resource/reduction.js';
+import type { WorldWritten } from '../resource/written.js';
 import type { Commands } from './commands.js';
 import type { Declaration } from './declaration.js';
 import type { Listed, Property } from './property.js';
 import type { RenderContext } from './render.js';
 import type { ComponentValues, LookupFunction, ResourceValues, Values } from './values.js';
 
-/** `read` values are read-only, `write` values readable and writable. */
+/** The components every entity a declaration matches has: those in `with`, `added` and `changed`. */
+export type Members<D> =
+    | Listed<Property<D, "components">, "with"> | Listed<Property<D, "components">, "added"> | Listed<Property<D, "components">, "changed">;
+
+/** Whether a declaration only reads: an observer or a render system. */
+type Reading<D> = D extends { readonly observer: true } | { readonly shader: object } ? true : false;
+
+/** The components a declaration's rows hold only where an entity has them. */
+export type Optional<D> = Exclude<Listed<Property<D, "components">, "optional">, Members<D>>;
+
+/** Each optional component's value or `undefined`, as `ComponentValues` gives members'. */
+type OptionalValues = { readonly [K in Component.Key]: Component<K> | undefined };
+
+/**
+ * Its members' values, writable but for references and shared components, and in a system that only reads; its
+ * optional components' too, or `undefined` where an entity lacks one, which assigning to fails the system. A shared
+ * component reads as its archetype's value, which only `commands.add` changes, by moving the entity.
+ */
 export type Row<D extends Declaration> =
     { readonly entity: Entity }
-    & Values<Listed<Property<D, "components">, "read">, Listed<Property<D, "components">, "write">, Component.Key, ComponentValues>;
+    & Values<Members<D>, Reading<D> extends true ? never : Members<D> & Writable, Component.Key, ComponentValues>
+    & Values<Optional<D>, Reading<D> extends true ? never : Optional<D> & Writable, Component.Key, OptionalValues>;
+
+/** Resources systems write: every one but those reduced, which only their contributors' fold sets, and those only the world writes. */
+type Writes = Exclude<Resource.Key, Reduced | WorldWritten>;
+
+/** Every resource, read-only. */
+export type ReadResources = Values<Resource.Key, never, Resource.Key, ResourceValues>;
+
+/** Every resource, writable as `Writes` says. */
+export type WriteResources = Values<Resource.Key, Writes, Resource.Key, ResourceValues>;
+
+/** Each reduced resource, as a function contributing a value to the run's fold. */
+type Reductions = { readonly [K in Reduced]: (value: Resource<K>) => void };
 
-type Resources<D> = Listed<Property<D, "resources">, "read"> | Listed<Property<D, "resources">, "write"> | Is<D>;
 type Is<D> = Listed<Property<D, "resources">, "is">;
-type Reduced<D> = keyof Property<D, "reduce"> & Resource.Key;
 
 /**
- * What a body uses besides its row, by kind, under the declaration's own keys: each is present only when the
- * declaration declares something of its kind. `commands` is there for every system but a GPU kernel, a render system
- * and an observer system.
+ * What a body uses besides its row: every resource, its lookups by name, the resources it may reduce into, its
+ * parent's values with `up`, and its commands, there for every system but a GPU kernel, a render system and an
+ * observer system. The build infers which of them the body reads and writes.
  */
 export type Context<D extends Declaration> =
-    ([Resources<D>] extends [never] ? {} : {
-        readonly resources: Values<Listed<Property<D, "resources">, "read">, Listed<Property<D, "resources">, "write">, Resource.Key, ResourceValues>
-            & { readonly [K in Is<D> & Resource.Key]: Holding<K> };
-    })
+    {
+        readonly resources: (Reading<D> extends true ? ReadResources : WriteResources) & { readonly [K in Is<D> & Resource.Key]: Holding<K> };
+    }
     & ([keyof Property<D, "lookup">] extends [never] ? {} : {
         readonly lookup: { readonly [K in keyof Property<D, "lookup">]: LookupFunction<Property<D, "lookup">[K]> };
     })
-    & ([Reduced<D>] extends [never] ? {} : {
-        /** Each resource it reduces into, as a function contributing a value to the run's fold. */
-        readonly reduce: { readonly [K in Reduced<D>]: (value: Resource.Value<K>) => void };
-    })
-    & (Property<D, "input"> extends Schema ? { readonly input: Schema.ToType<Property<D, "input">> } : {})
+    & (Reading<D> extends true ? {} : { readonly reduce: Reductions })
     & (Property<D, "up"> extends object ? {
-        /** The parent's `up.read` values, or null for a row without a parent. */
-        readonly up: { readonly [K in Listed<Property<D, "up">, "read"> & Component.Key]: Component.Value<K> } | null;
+        /** The parent's values the body reads, or null for a row without a parent or whose parent lacks one of them. */
+        readonly up: ComponentValues | null;
     } : {})
     & (D extends { readonly kernel: "gpu" } | { readonly shader: object } | { readonly observer: true } ? {} : { readonly commands: Commands });
 
-/** `(row, context)` for a system with `components`, `(context)` for one without, and `(gpu, context)` for a render system. */
-export type Body<D extends Declaration> =
+/**
+ * `(row, context, input)` for a system with `components`, `(context, input)` for one without, and `(gpu, context)` for
+ * a render system. `input` is the value each run passes, of the type the body gives its parameter; a body without one
+ * takes none.
+ */
+export type Body<D extends Declaration, I = undefined> =
     D extends { readonly shader: object } ? (gpu: RenderContext, context: Context<D>) => void :
-    Property<D, "components"> extends undefined ? (context: Context<D>) => void :
-    (row: Row<D>, context: Context<D>) => void;
+    D extends { readonly components: object } ? (row: Row<D>, context: Context<D>, input: I) => void :
+    (context: Context<D>, input: I) => void;

package/src/interface/system/check.ts

@@ -1,16 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { layoutOf } from '../registry/layout.js';
-import { declarationOf, kindOf, labelOf } from '../registry/names.js';
+import { declarationOf, kindOf, labelOf, whyUnregistered } from '../registry/names.js';
 import { definitionOf } from '../registry/program.js';
 import { reducedBy, scheduleOf } from '../registry/schedule.js';
-import { conditional } from '../registry/schemas.js';
+import { conditional, matchesSchema } from '../registry/schemas.js';
 import { requireRegistered, threadOf } from '../registry/threads.js';
 import { checkWorldWritten } from '../registry/written.js';
 import { checkLookup, indexDefinitionOf, lookupKeysOf, orderKeysOf } from '../registry/indexes.js';
-import { labelOfItem } from '../registry/items.js';
 import type { Schema } from '../schema/schema.js';
 import type { Composite } from './composite.js';
 import type { Definition } from './definition.js';
-import type { Leaf } from './leaf.js';
+import type { InputSchema, Leaf } from './leaf.js';
 
 type Key = symbol;
 
@@ -22,18 +22,15 @@ const checkLists = (name: string, what: string, lists: { readonly read?: readonl
 };
 
 /**
- * Throws if a leaf reduces into a resource with an operator its `reduce` trait doesn't declare, or also reads, writes
- * or filters on it, or writes a resource that's reduced, which only its contributors' fold sets.
+ * Throws if a leaf reduces into a resource without a `reduce` trait, which gives the operator it folds with, or also
+ * reads, writes or filters on it, or writes a resource that's reduced, which only its contributors' fold sets.
  */
 const checkReductions = (leaf: Leaf): void => {
     const { name } = leaf;
-    const { reduce, resources } = leaf.declaration;
+    const { resources } = leaf.declaration;
     const others = new Set<Key>([...resources?.read ?? [], ...resources?.write ?? [], ...resources?.changed ?? []]);
     for (const key of reducedBy(leaf)) {
-        const declared = declarationOf(key)?.reduce;
-        const operator: unknown = Reflect.get(reduce ?? {}, key);
-        if (declared === undefined) throw new Error(`System "${name}" reduces "${labelOf(key)}", which has no reduce trait.`);
-        if (declared !== operator) throw new Error(`System "${name}" reduces "${labelOf(key)}" with "${labelOf(operator)}", but it's declared reduce: "${labelOf(declared)}".`);
+        if (declarationOf(key)?.reduce === undefined) throw new Error(`System "${name}" reduces "${labelOf(key)}", which has no reduce trait.`);
         if (others.has(key)) throw new Error(`System "${name}" reduces "${labelOf(key)}", so it can't also read, write or filter on it.`);
     }
     for (const key of resources?.write ?? []) {
@@ -53,7 +50,7 @@ const checkConditions = (leaf: Leaf): void => {
     const listed = new Set<Key>([...resources?.read ?? [], ...resources?.write ?? []]);
     for (const key of [...is, ...not]) {
         const declaration = declarationOf(key);
-        if (kindOf(key) !== "resource" || declaration === undefined) throw new Error(`System "${name}" runs on the condition of "${labelOf(key)}", which isn't a registered resource.`);
+        if (kindOf(key) !== "resource" || declaration === undefined) throw new Error(`System "${name}" runs on the condition of "${labelOf(key)}", which isn't a registered resource: ${whyUnregistered(key)}.`);
         const { type } = declaration;
         if (type !== undefined && !conditional(type)) throw new Error(`System "${name}" runs on the condition of "${labelOf(key)}", which is never null or false.`);
     }
@@ -69,6 +66,30 @@ const unreadByKernels = (key: symbol): string | null => {
     return kind === "object" ? "which isn't stored in linear memory" : kind === "string" ? "a string, which kernels don't read yet" : null;
 };
 
+/**
+ * What of a leaf's ordering index and lookups a kernel can't read, or null: workers read them from shared memory, so
+ * their values must be linear there too.
+ */
+export const unreadByKernel = (leaf: Leaf): string | null => {
+    const { lookup, order } = leaf.declaration;
+    if (order !== undefined) {
+        for (const key of orderKeysOf(leaf.declaration)) {
+            const unread = unreadByKernels(key);
+            if (unread !== null) return `its rows are ordered by an index keyed by "${labelOf(key)}", ${unread}`;
+        }
+    }
+    const lookups = Object.values(lookup ?? {});
+    for (const key of lookups.flatMap(found => found.read ?? [])) {
+        const unread = unreadByKernels(key);
+        if (unread !== null) return `a lookup reads "${labelOf(key)}", ${unread}`;
+    }
+    for (const key of lookups.flatMap(lookupKeysOf)) {
+        const unread = unreadByKernels(key);
+        if (unread !== null) return `a lookup goes through an index keyed by "${labelOf(key)}", ${unread}`;
+    }
+    return null;
+};
+
 /**
  * Throws for what a leaf's kind and placement rule out: `up` without components or through a key that isn't a reference
  * component, `order` by anything but a sorted index, without components, with `up` or on the GPU, a kernel's lookup of
@@ -82,16 +103,10 @@ const checkPlacement = (leaf: Leaf): void => {
     if (order !== undefined) {
         const index = indexDefinitionOf(order);
         if (index === undefined) fail("orders its rows by a value Index.create didn't return");
-        else if (index.declaration.sorted !== true) fail(`orders its rows by index "${labelOfItem(index)}", which isn't sorted`);
+        else if (index.declaration.sorted !== true) fail(`orders its rows by index "${index.name}", which isn't sorted`);
         if (components === undefined) fail("orders its rows without components, so it runs once");
         if (up !== undefined) fail("uses both up and order, which both decide the order of its rows");
         if (kernel === "gpu") fail("can't run on the GPU: GPU kernels have no order yet");
-        if (kernel !== undefined) {
-            for (const key of orderKeysOf(leaf.declaration)) {
-                const unread = unreadByKernels(key);
-                if (unread !== null) throw new Error(`Kernel "${name}": its rows are ordered by an index keyed by "${labelOf(key)}", ${unread}.`);
-            }
-        }
     }
     if (up !== undefined) {
         if (components === undefined) fail("uses up, which orders rows, without components");
@@ -100,16 +115,9 @@ const checkPlacement = (leaf: Leaf): void => {
         }
     }
     const lookups = Object.values(lookup ?? {});
-    if (kernel !== undefined) {
-        // Workers read lookups from shared memory, so their values must be linear there too.
-        for (const key of lookups.flatMap(found => found.read ?? [])) {
-            const unread = unreadByKernels(key);
-            if (unread !== null) throw new Error(`Kernel "${name}": a lookup reads "${labelOf(key)}", ${unread}.`);
-        }
-        for (const key of lookups.flatMap(lookupKeysOf)) {
-            const unread = unreadByKernels(key);
-            if (unread !== null) throw new Error(`Kernel "${name}": a lookup goes through an index keyed by "${labelOf(key)}", ${unread}.`);
-        }
+    if (kernel === true || kernel === "gpu") {
+        const unread = unreadByKernel(leaf);
+        if (unread !== null) throw new Error(`Kernel "${name}": ${unread}.`);
     }
     const reduces = reducedBy(leaf).length > 0;
     if (kernel === "gpu") {
@@ -121,6 +129,23 @@ const checkPlacement = (leaf: Leaf): void => {
     if ((leaf.declaration.shader !== undefined) !== (leaf.kind === "render")) fail("has a shader only when System.render makes it");
 };
 
+/**
+ * Throws for a `where` naming what isn't a shared component, giving one a value not of its type, or with `up`, `order`
+ * or a target, which run rows across archetypes.
+ */
+const checkWhere = (leaf: Leaf): void => {
+    const { name, declaration } = leaf;
+    const where = declaration.components?.where;
+    if (where === undefined) return;
+    if (declaration.up !== undefined || declaration.order !== undefined || declaration.target !== undefined) throw new Error(`System "${name}" uses where with up, order or a target, which run rows across archetypes.`);
+    for (const key of Object.getOwnPropertySymbols(where)) {
+        const found = declarationOf(key);
+        if (kindOf(key) !== "component" || found?.shared !== true) throw new Error(`System "${name}": where names "${labelOf(key)}", which isn't a shared component: where keeps a system to archetypes by their shared values.`);
+        const value: unknown = Reflect.get(where, key);
+        if (typeof value !== "function" && found.type !== undefined && !matchesSchema(found.type, value)) throw new Error(`System "${name}": where gives "${labelOf(key)}" ${labelOf(value)}, which isn't one of its type's values.`);
+    }
+};
+
 /**
  * Throws for what an observer system can't declare: it only reads, after a sync point, so it writes and reduces into
  * nothing, takes no input, isn't a kernel or a render system, has no `up`, and is ordered with nothing.
@@ -132,23 +157,22 @@ const checkObserver = (leaf: Leaf): void => {
     const fail = (message: string): never => { throw new Error(`System "${name}" is an observer, so it ${message}.`); };
     if (observer !== true) throw new Error(`System "${name}": observer is true or left out.`);
     if (leaf.kind === "render") fail("records no GPU work");
-    if (declaration.kernel !== undefined) fail("isn't a kernel");
+    if (declaration.kernel === true || declaration.kernel === "gpu") fail("isn't a kernel");
     if ((declaration.components?.write?.length ?? 0) + (declaration.resources?.write?.length ?? 0) > 0) fail("writes nothing");
     if (reducedBy(leaf).length > 0) fail("reduces into nothing");
-    if (declaration.input !== undefined) fail("takes no input");
+    if (leaf.input !== undefined) fail("takes no input");
     if (declaration.up !== undefined) fail("has no up");
     if ((declaration.before?.length ?? 0) + (declaration.after?.length ?? 0) + (declaration.during?.length ?? 0) > 0) fail("is ordered with nothing");
 };
 
 /**
  * Throws for a leaf that names a component or resource that isn't registered as one, lists a key in both `read` and
- * `write`, writes a reference, has a lookup reading a component it writes, takes input that isn't an object schema,
- * uses object components and resources of different threads, declares what an observer system can't, or whose
+ * `write`, writes a reference, has a lookup reading a component it writes, uses object components and resources of different threads, declares what an observer system can't, or whose
  * reductions, conditions, `up` or placement can't hold.
  */
 export const checkLeaf = (leaf: Leaf): void => {
     const { name, declaration } = leaf;
-    const { components, resources, lookup, input } = declaration;
+    const { components, resources, lookup } = declaration;
     checkLists(name, "components", components);
     checkLists(name, "resources", resources);
     checkWorldWritten(`System "${name}"`, resources?.write);
@@ -165,12 +189,6 @@ export const checkLeaf = (leaf: Leaf): void => {
     for (const key of orderKeysOf(declaration)) {
         if (writes.has(key)) throw new Error(`System "${name}": its rows are ordered by an index keyed by "${labelOf(key)}", which the system writes.`);
     }
-    if (input !== undefined) {
-        const schema: Schema = input;
-        if (!("type" in schema) || schema.type !== "object" || typeof schema.properties !== "object" || schema.properties === null) {
-            throw new Error(`System "${name}": input is an object schema of named fields.`);
-        }
-    }
     checkTarget(leaf);
     threadOf(declaration, "System", name);
     requireRegistered("System", name, "component", components?.has);
@@ -182,28 +200,48 @@ export const checkLeaf = (leaf: Leaf): void => {
     }
     for (const key of components?.write ?? []) {
         if (declarationOf(key)?.reference !== undefined) throw new Error(`System "${name}" writes "${labelOf(key)}", a reference, which changes only through commands.`);
+        if (declarationOf(key)?.shared === true) throw new Error(`System "${name}" writes "${labelOf(key)}", a shared component, whose value is its archetype's: give it another with commands.add.`);
     }
     checkObserver(leaf);
+    checkWhere(leaf);
     checkReductions(leaf);
     checkConditions(leaf);
     checkPlacement(leaf);
 };
 
+const isInputSchema = (value: unknown): value is InputSchema =>
+    typeof value === "object" && value !== null && Reflect.get(value, "type") === "object"
+    && typeof Reflect.get(value, "properties") === "object" && Reflect.get(value, "properties") !== null;
+
+/**
+ * The schema of a body's input, which the plugin passes from the type of its parameter after the `before` before it.
+ * Throws for a body taking input without one, as one not built with the plugin does, and for a schema that isn't an
+ * object of named fields.
+ */
+export const inputSchemaOf = (name: string, body: (...parameters: never[]) => void, before: number, input: unknown): InputSchema | undefined => {
+    if (input === undefined) {
+        if (body.length > before) throw new Error(`System "${name}" takes input, whose schema the plugin gives from the type of its body's parameter: write its body in place and build it with Compiler.plugin().`);
+        return undefined;
+    }
+    if (!isInputSchema(input)) throw new Error(`System "${name}": input is an object schema of named fields.`);
+    return input;
+};
+
 /**
  * Throws if a system on one entity takes it from what isn't an entity field of its input, has no components, or is a
  * kernel, has `up` or `order`, or reduces.
  */
 const checkTarget = (leaf: Leaf): void => {
-    const { name, declaration } = leaf;
-    const { target, input, components, kernel, up, order, reduce } = declaration;
+    const { name, declaration, input } = leaf;
+    const { target, components, kernel, up, order, resources } = declaration;
     if (target === undefined) return;
     const fail = (message: string): never => { throw new Error(`System "${name}" runs on one entity, so it ${message}.`); };
     const field: Schema | undefined = input !== undefined && "properties" in input ? Reflect.get(input.properties, target) : undefined;
     if (field === undefined || !("format" in field) || field.format !== "entity") fail(`takes it from an input field "${target}" holding an entity`);
     if (components === undefined) fail("needs components");
-    if (kernel !== undefined) fail("isn't a kernel");
+    if (kernel === true || kernel === "gpu") fail("isn't a kernel");
     if (up !== undefined || order !== undefined) fail("has no up or order");
-    if (reduce !== undefined) fail("reduces into nothing");
+    if ((resources?.reduce?.length ?? 0) > 0) fail("reduces into nothing");
 };
 
 /** Every leaf under a system, each once. Throws for a member no System constructor returned. */

package/src/interface/system/commands.ts

@@ -1,10 +1,48 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 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
@@ -12,10 +50,17 @@ type ValueArgument<K extends Essential> = Component.Value<K> extends true ? [val
  */
 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/src/interface/system/commands.type-test.ts

@@ -1,6 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Resource } from '../resource/resource.js';
 import { Component } from '../component/component.js';
-import { Archetype } from '../archetype/archetype.js';
 import type { Entity } from '../entity/entity.js';
 import type { Commands } from './commands.js';
 
@@ -25,14 +25,8 @@ declare module '@adobe/ecs' {
         [time]: { type: number };
     }
 }
-Component.register(position, { type: { type: "number" } });
-Component.register(velocity, { type: { type: "number" } });
-Component.register(label, { type: { anyOf: [{ type: "string" }, { type: "null" }] } });
-Component.register(player, { type: { const: true } });
-Component.register(slot, { type: { type: "number", default: 0 }, derived: true });
-Resource.register(time, { type: { type: "number", default: 0 } });
 
-const particle = Archetype.create([position, velocity, label, player]);
+const particle = [position, velocity, label, player] as const;
 
 export const issue = (commands: Commands, entity: Entity): void => {
     // `spawn` is curried: the components first, then their values, giving an entity.

package/src/interface/system/composite-declaration.ts

@@ -1,9 +1,8 @@
-import type { Name } from './name.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 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/src/interface/system/composite-input.type-test.ts

@@ -1,63 +1,47 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { World } from '../world/world.js';
 import { System } from './system.js';
 
 type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
 const check = <_T extends true>() => { };
 
-const move = System.create({
-    name: "compositeInputTest/move",
-    input: { type: "object", properties: { distance: { type: "number" } } },
-}, ({ input }) => { void input.distance; });
-const step = System.create({
-    name: "compositeInputTest/step",
-    input: { type: "object", properties: { distance: { type: "number" }, dt: { type: "number" } } },
-}, ({ input }) => { void input.dt; });
-const pause = System.create({
-    name: "compositeInputTest/pause",
-    input: { type: "object", properties: { dt: { type: "number" } }, required: [] },
-}, ({ input }) => { void input.dt; });
-const label = System.create({
-    name: "compositeInputTest/label",
-    input: { type: "object", properties: { distance: { type: "string" } } },
-}, ({ input }) => { void input.distance; });
-const idle = System.create({ name: "compositeInputTest/idle" }, () => {});
+const move = System.create({}, (_context, input: { readonly distance: number }) => { void input.distance; });
+const step = System.create({}, (_context, input: { readonly distance: number; readonly dt: number }) => { void input.dt; });
+const pause = System.create({}, (_context, input: { readonly dt?: number }) => { void input.dt; });
+const label = System.create({}, (_context, input: { readonly distance: string }) => { void input.distance; });
+const idle = System.create({}, () => {});
 
 // A composite takes every field its members' inputs have; a field in several is one value for all of them.
-const frame = System.create({ name: "compositeInputTest/frame", systems: [move, step, idle] });
+const frame = System.create({ systems: [move, step, idle] });
 check<Equal<typeof frame, System<{ readonly distance: number; readonly dt: number }>>>();
 
 // A field optional in one member and required in another is required.
-const paused = System.create({ name: "compositeInputTest/paused", systems: [pause, step] });
+const paused = System.create({ systems: [pause, step] });
 check<Equal<typeof paused, System<{ readonly dt: number; readonly distance: number }>>>();
 
 // Nested composites take their members' fields too.
-const outer = System.create({ name: "compositeInputTest/outer", systems: [System.create({ name: "compositeInputTest/inner", systems: [move] }), pause] });
+const outer = System.create({ systems: [System.create({ systems: [move] }), pause] });
 check<Equal<typeof outer, System<{ readonly distance: number; readonly dt?: number }>>>();
 
-// A composite without a name or constraints is its list of members.
+// A composite without constraints is its list of members.
 const listed = System.create([move, step, idle]);
 check<Equal<typeof listed, System<{ readonly distance: number; readonly dt: number }>>>();
 const constrained = System.create({ systems: [pause], after: [listed] });
 check<Equal<typeof constrained, System<{ readonly dt?: number }>>>();
 
 // Without inputs, a composite takes none.
-const quiet = System.create({ name: "compositeInputTest/quiet", systems: [idle] });
+const quiet = System.create({ systems: [idle] });
 check<Equal<typeof quiet, System>>();
 
 // @ts-expect-error a field with different types in two members is an error at the member
-System.create({ name: "compositeInputTest/conflict", systems: [move, label] });
+System.create({ systems: [move, label] });
 // @ts-expect-error in a list of members too
 System.create([move, label]);
 // @ts-expect-error a composite declaration lists its systems
-System.create({ name: "compositeInputTest/empty", after: [move] });
+System.create({ after: [move] });
 
 declare const world: World;
 void world.run(frame, { distance: 1, dt: 0.5 });
 // @ts-expect-error run takes every field
 void world.run(frame, { distance: 1 });
 
-System.create({
-    name: "compositeInputTest/scalar",
-    // @ts-expect-error input is an object of named fields
-    input: { type: "number" },
-}, () => {});

package/src/interface/system/composite.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { CompositeDeclaration } from './composite-declaration.js';
 import type { Name } from './name.js';
 

package/src/interface/system/conditions.type-test.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Resource } from '../resource/resource.js';
 import { Component } from '../component/component.js';
 import { System } from './system.js';
@@ -24,45 +25,33 @@ declare module '@adobe/ecs' {
         [position]: { type: number };
     }
 }
-Resource.register(handle, { default: new Map() });
-Resource.register(level, { type: { anyOf: [{ type: "object", properties: { size: { type: "number" } } }, { type: "null" }], default: null } });
-Resource.register(paused, { type: { type: "boolean", default: false } });
-Resource.register(cache, {});
-Resource.register(count, { type: { type: "number", default: 0 } });
-Component.register(position, { type: { type: "number" } });
 
 // `is`: runs while each is neither null nor false, and reads it narrowed so.
-System.create({ name: "conditionsTypeTest/loaded", resources: { is: [level, cache] } }, ({ resources }) => {
+System.create({ resources: { is: [level, cache] } }, ({ resources }) => {
     check<Equal<typeof resources[typeof level], { readonly size: number }>>();
     check<Equal<typeof resources[typeof cache], Map<string, number>>>();
     // @ts-expect-error a condition is read-only
     resources[level] = null;
 });
-System.create({ name: "conditionsTypeTest/playing", resources: { is: [paused] } }, ({ resources }) => {
+System.create({ resources: { is: [paused] } }, ({ resources }) => {
     check<Equal<typeof resources[typeof paused], true>>();
 });
 
-// `not`: runs while each is null or false; its value is known, so it isn't readable.
-System.create({ name: "conditionsTypeTest/running", components: { write: [position] }, resources: { not: [paused] } }, (row, context) => {
+// `not`: runs while each is null or false.
+System.create({ components: { with: [position] }, resources: { not: [paused] } }, row => {
     row[position] += 1;
-    // @ts-expect-error a `not` condition isn't readable
-    void context.resources;
 });
 
 // Only a resource whose type allows null or false is a condition.
 // @ts-expect-error a number is never null or false
-System.create({ name: "conditionsTypeTest/counted", resources: { is: [count] } }, () => {});
+System.create({ resources: { is: [count] } }, () => {});
 // @ts-expect-error a value that isn't data and doesn't allow null is never null
-System.create({ name: "conditionsTypeTest/handled", resources: { not: [handle] } }, () => {});
+System.create({ resources: { not: [handle] } }, () => {});
 
-// A condition is listed once: `is` already makes it readable, and a written value would have two types.
+// A condition is listed once.
 // @ts-expect-error both is and not
-System.create({ name: "conditionsTypeTest/both", resources: { is: [paused], not: [paused] } }, () => {});
-// @ts-expect-error is already makes it readable
-System.create({ name: "conditionsTypeTest/read", resources: { is: [level], read: [level] } }, () => {});
-// @ts-expect-error a condition isn't written
-System.create({ name: "conditionsTypeTest/write", resources: { is: [level], write: [level] } }, () => {});
+System.create({ resources: { is: [paused], not: [paused] } }, () => {});
 
 // Kernels and render systems take conditions too.
-System.create({ name: "conditionsTypeTest/kernel", kernel: "cpu", components: { write: [position] }, resources: { not: [paused] } }, row => { row[position] += 1; });
-System.render({ name: "conditionsTypeTest/draw", resources: { is: [level] }, shader: { accessors: { place: position } } }, () => {});
+System.create({ kernel: true, components: { with: [position] }, resources: { not: [paused] } }, row => { row[position] += 1; });
+System.render({ resources: { is: [level] }, shader: { accessors: { place: position } } }, () => {});

package/src/interface/system/create-resolved.ts

@@ -0,0 +1,21 @@
+// © 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';
+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 const createResolved = (declaration: Resolved, body: Leaf["body"], input?: unknown): System<unknown> => {
+    const name = nameOf(declaration, undefined, "system");
+    const schema = inputSchemaOf(name, body, declaration.components === undefined ? 1 : 2, input);
+    const system: Leaf & System<unknown> = { kind: "system", name, declaration, input: schema, body };
+    checkLeaf(system);
+    claimSystem(system, undefined);
+    return system;
+};