@adobe/ecs 0.1.0 → 0.2.1

package/src/interface/component/index.ts

@@ -1,3 +1,3 @@
-export * from './register.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 export type { Key } from './key.js';
-export type { Value, With } from './value.js';
+export type { With } from './value.js';

package/src/interface/component/key.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Components } from './types.js';
 
 export type Key = keyof Components;

package/src/interface/component/key.type-test.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Component, Resource } from "@adobe/ecs";
 import type { Key as TraitKey } from "../trait/key.js";
 
@@ -15,8 +16,6 @@ declare module "@adobe/ecs" {
         readonly [mark]: true;
     }
 }
-Component.register(position, { type: { type: "number" } });
-Resource.register(scale, { type: { type: "number", default: 0 } });
 
 // Components, resources and traits are named by keys; systems, rules and finalizers by names.
 export const component: Component.Key = position;

package/src/interface/component/register.test.ts

@@ -1,8 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import { Entity } from "../entity/entity.js";
+import { registerComponent } from "../registry/declarations.js";
+import { addTrait } from "../registry/traits.js";
 import { declarationOf, kindOf, threadOfDeclaration } from "../registry/index.js";
-import { Trait } from "../trait/trait.js";
-import { Component } from "./component.js";
 
 const parent = Symbol("typesComponentTest/parent");
 const count = Symbol("typesComponentTest/count");
@@ -27,32 +28,17 @@ declare module "@adobe/ecs" {
         [position]: { type: readonly [number, number] };
         [bitmap]: { type: ImageBitmap; transfer: true };
         [marked]: { type: true; [mark]: true };
-        [slot]: { type: number; derived: true };
+        [slot]: { type: number; derived: true; default: 0 };
     }
     export interface Traits<N> {
         readonly [mark]: true;
-        readonly [late]: true;
     }
 }
 
-Trait.register(mark);
-Component.register(parent, { type: Entity.schema, reference: "owner" });
-Component.register(count, { type: { type: "number" } });
-Component.register(label, { type: { type: "string" } });
-Component.register(placed, { type: { type: "array", items: { type: "string" } }, thread: "typesComponentTest" });
-Component.register(position, { type: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2 } });
-Component.register(bitmap, { transfer: true });
-Component.register(marked, { type: { const: true }, [mark]: true });
-Component.register(slot, { type: { type: "number", default: 0 }, derived: true });
+/** Registers a declaration as the build does, which a test may write wrong. */
+const register = (key: unknown, declaration: object): void => registerComponent(key, declaration);
 
-const untyped: (...parameters: never[]) => unknown = Component.register;
-
-/** Registers as an untyped caller would, bypassing the types' checks. */
-const register = (key: unknown, declaration: object): void => {
-    Reflect.apply(untyped, undefined, [key, declaration]);
-};
-
-describe("Component.register", () => {
+describe("registering a component", () => {
     it("records the declaration, and its thread: none for a struct or a string, else its own or \"world\"", () => {
         expect(declarationOf(parent)).toEqual({ type: Entity.schema, reference: "owner" });
         expect(kindOf(parent)).toBe("component");
@@ -67,31 +53,37 @@ describe("Component.register", () => {
         expect(threadOfDeclaration({ type: { anyOf: [{ type: "string" }, { type: "number" }] } })).toBe("world");
     });
     it("accepts the same declaration again, as a module evaluated again makes it, and rejects a different one or a key of another kind", () => {
-        expect(() => Component.register(count, { type: { type: "number" } })).not.toThrow();
+        expect(() => register(count, { type: { type: "number" } })).not.toThrow();
         expect(() => register(count, { type: { type: "integer" } })).toThrow(`Cannot register component "typesComponentTest/count": already registered as a component, with another declaration.`);
         expect(declarationOf(count)).toEqual({ type: { type: "number" } });
         const claimed = Symbol("typesComponentTest/claimed");
         register(claimed, { type: { const: true } });
-        expect(() => Reflect.apply(Trait.register, undefined, [claimed])).toThrow(`Cannot register trait "typesComponentTest/claimed": already registered as a component.`);
+        expect(() => addTrait(claimed)).toThrow(`Cannot register trait "typesComponentTest/claimed": already registered as a component.`);
         expect(kindOf(count)).toBe("component");
     });
     it("takes only plain symbols as keys, so built-in traits' string names are no component's", () => {
-        // @ts-expect-error a key is a symbol, and derived is a built-in trait's name
-        expect(() => Component.register("derived", { type: { const: true } })).toThrow(`Cannot register component "derived": a key is a plain Symbol(...), not a string.`);
-        expect(() => register(Symbol.for("typesComponentTest/shared"), { type: { const: true } })).toThrow("a Symbol.for key is shared across the program");
+        expect(() => register("derived", { type: { const: true } })).toThrow(`Cannot register component "derived": a key is a plain Symbol(...), not a string.`);
+        expect(() => register(Symbol.for("shared"), { type: { const: true } })).toThrow("a Symbol.for key is shared across the program");
         expect(() => register(Symbol.asyncIterator, { type: { const: true } })).toThrow("Symbol.asyncIterator is a well-known symbol.");
         expect(kindOf("derived")).toBe(undefined);
     });
-    it("rejects what types reject, for untyped callers, recording nothing", () => {
+    it("rejects a declaration whose traits can't hold, recording nothing", () => {
         expect(() => register(Symbol("typesComponentTest/strayTrait"), { type: { type: "number" }, unknown: true })).toThrow("unknown isn't a registered trait");
         expect(() => register(Symbol("typesComponentTest/badReference"), { type: { type: "number" }, reference: "weak" })).toThrow("a reference's type is Entity.schema");
-        expect(() => register(Symbol("typesComponentTest/badSlot"), { type: { type: "number" }, derived: true })).toThrow("a derived component's type has a default");
+        expect(() => register(Symbol("typesComponentTest/badSlot"), { type: { type: "number" }, derived: true })).toThrow("a derived component has a default");
         expect(() => register(Symbol("typesComponentTest/reduced"), { type: { type: "number" }, reduce: "+" })).toThrow("only a resource is reduced");
+        expect(() => register(Symbol("typesComponentTest/derivedWithin"), { type: { type: "number" }, default: 0, derived: true, within: count })).toThrow("a derived component's rule covers within");
+        expect(() => register(Symbol("typesComponentTest/derivedReference"), { type: { ...Entity.schema }, default: Entity.none, derived: true, reference: "owner" })).toThrow("a rule can't set a derived component's target");
         const badReference = Symbol("typesComponentTest/badReference");
         expect(() => register(badReference, { type: { type: "number" }, reference: "weak" })).toThrow("a reference's type is Entity.schema");
         expect(declarationOf(badReference)).toBe(undefined);
         expect(kindOf(badReference)).toBe(undefined);
     });
+    it("rejects a default that isn't one of its type's values, however it's given", () => {
+        expect(() => register(Symbol("typesComponentTest/tallHeight"), { type: { type: "number", precision: 1 }, default: "tall" })).toThrow("its default, tall, isn't one of its type's values");
+        expect(() => register(Symbol("typesComponentTest/lowLevel"), { type: { type: "integer", minimum: 1, maximum: 9 }, default: 0, derived: true })).toThrow("isn't one of its type's values");
+        expect(() => register(Symbol("typesComponentTest/floor"), { type: { type: "number", precision: 1 }, default: -Infinity })).not.toThrow();
+    });
     it("rejects a schema whose GPU layout can't hold it", () => {
         expect(() => register(Symbol("typesComponentTest/storageText"), { type: { type: "array", items: { type: "string" }, layout: "storage" } })).toThrow("layout needs numbers");
     });
@@ -107,18 +99,19 @@ describe("Component.register", () => {
     it("records no type for a value that isn't data", () => {
         expect(declarationOf(bitmap)).toEqual({ transfer: true });
         expect(Reflect.has(declarationOf(bitmap) ?? {}, "type")).toBe(false);
-        expect(() => Component.register(bitmap, { transfer: true })).not.toThrow();
+        expect(() => register(bitmap, { transfer: true })).not.toThrow();
     });
-    it("rejects a default beside a component's schema, which holds it", () => {
-        expect(() => register(Symbol("typesComponentTest/defaulted"), { type: { type: "number" }, default: 0 })).toThrow("its schema holds its default");
+    it("takes a component's default beside its schema, never in it", () => {
+        expect(() => register(Symbol("typesComponentTest/defaulted"), { type: { type: "number" }, default: 0 })).not.toThrow();
+        expect(() => register(Symbol("typesComponentTest/inSchema"), { type: { type: "number", default: 0 } })).toThrow("its schema holds a default, which a schema never does");
     });
     it("takes traits other packages register, in the namespace components share", () => {
         const early = Symbol("typesComponentTest/early");
         expect(() => register(early, { type: { const: true }, [late]: true })).toThrow(`typesComponentTest/late isn't a registered trait`);
-        Trait.register(late);
+        addTrait(late);
         expect(() => register(early, { type: { const: true }, [late]: true })).not.toThrow();
         expect(declarationOf(marked)).toEqual({ type: { const: true }, [mark]: true });
-        expect(() => Trait.register(mark)).not.toThrow();
-        expect(declarationOf(slot)).toEqual({ type: { type: "number", default: 0 }, derived: true });
+        expect(() => addTrait(mark)).not.toThrow();
+        expect(declarationOf(slot)).toEqual({ type: { type: "number" }, default: 0, derived: true });
     });
 });

package/src/interface/component/types.ts

@@ -1,6 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /**
- * Each component's traits, `type` included, by augmentation: `[position]: { type: Vec3 }`,
- * `[slot]: { type: Slot; derived: true }`. Registration must give exactly these.
+ * Each component's traits, `type` and its `default` included, by augmentation in the module declaring its key:
+ * `[position]: { type: Vec3 }`, `[slot]: { type: Slot; derived: true; default: 0 }`. The build registers each.
  */
 export interface Components {
 }

package/src/interface/component/value.ts

@@ -1,18 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { ThreadOf } from '../thread/of.js';
 import type { Key as TraitKey } from "../trait/key.js";
 import type { Key } from "./key.js";
 import type { Components } from "./types.js";
 
-/** Every component's value type, computed once so `Value` is a lookup. */
-type ValueTypes = { readonly [K in Key]: Components[K] extends { readonly type: infer T } ? T : never };
+/** Every component's value type, computed once so `Type` is a lookup. */
+type Types = { readonly [K in Key]: Components[K] extends { readonly type: infer T } ? T : never };
 
 /** The value type of component `K`. */
-export type Value<K extends Key> = ValueTypes[K];
+export type Type<K extends Key> = Types[K];
 
 type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 
 /** Component `K`'s value as reads return it: read-only, with branded primitives such as `Entity` as they are. */
-export type ReadonlyValue<K extends Key> = Value<K> extends Primitive ? Value<K> : Readonly<Value<K>>;
+export type ReadonlyType<K extends Key> = Type<K> extends Primitive ? Type<K> : Readonly<Type<K>>;
 
 /** Components that declare trait `T`, with a value assignable to `V`. */
 export type With<T extends TraitKey, V = unknown> = { [K in Key]: Components[K] extends { readonly [P in T]: V } ? K : never }[Key];
@@ -24,11 +25,17 @@ export type Derived = With<"derived">;
 /** Components user code adds and removes: the only ones commands take. */
 export type Essential = Exclude<Key, Derived>;
 
-/** Components systems may write: every one but references, which change only through commands. */
-export type Writable = Exclude<Key, With<"reference">>;
+/** Components whose value is their archetype's, once for every entity it holds: those declared `shared`. */
+export type Shared = With<"shared">;
+
+/**
+ * Components systems may write: every one but references, which change only through commands, and shared ones, which
+ * only `commands.add` gives another value.
+ */
+export type Writable = Exclude<Key, With<"reference"> | Shared>;
 
 /** Every component's thread, computed once so `ThreadOf` is a lookup. */
-type Threads = { readonly [K in Key]: ThreadOf<Components[K], Value<K>> };
+type Threads = { readonly [K in Key]: ThreadOf<Components[K], Type<K>> };
 
 /** The thread component `K` lives on, or `never` for a struct, which lives in shared memory. */
 export type ThreadOfComponent<K extends Key> = Threads[K];

package/src/interface/component/values.ts

@@ -1,5 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Key } from "./key.js";
-import type { Value } from './value.js';
+import type { Type } from './value.js';
 
 /** Values for any subset of components, keyed by component. */
-export type Values = { readonly [K in Key]?: Value<K> };
+export type Values = { readonly [K in Key]?: Type<K> };

package/src/interface/entity/entity.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 declare const entityBrand: unique symbol;
 
 /**

package/src/interface/entity/index.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Schema } from '../schema/schema.js';
 import type { Entity } from './entity.js';
 
@@ -6,3 +7,6 @@ export const schema = { type: "integer", format: "entity" } as const satisfies S
 
 /** No entity: index 0 is never one, so zeroed memory and an entity-valued default mean none, and a lookup of it returns null. */
 export const none = 0 as Entity;
+
+/** What an entity-typed value starts at: none. */
+export { none as default };

package/src/interface/finalizer/body.ts

@@ -1,27 +1,28 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Component } from '../component/component.js';
 import type { Entity } from '../entity/entity.js';
-import type { Resource } from '../resource/resource.js';
 import type { Commands } from '../system/commands.js';
 import type { Listed, Property } from '../system/property.js';
-import type { LookupFunction, ResourceValues, Values } from '../system/values.js';
+import type { LookupFunction } from '../system/values.js';
+import type { WriteResources } from '../system/body.js';
 import type { ChangesDeclaration, Declaration } from './declaration.js';
-import type { Essential, ReadonlyValue } from '../component/value.js';
+import type { Essential, ReadonlyType } from '../component/value.js';
 import type { Elsewhere, ThreadsOf } from '../system/threads.js';
 
-/** The entity that stopped matching, with its `read` values as they are before the sync point applies. */
+/**
+ * The entity that stopped matching, with the values of its `with` as they are before the sync point applies, and of
+ * its `optional` where it had them, `undefined` where it didn't.
+ */
 export type Row<D extends Declaration> =
-    { readonly entity: Entity } & { readonly [K in Listed<Property<D, "components">, "read"> & Component.Key]: Component.Value<K> };
-
-type Resources<D> = Listed<Property<D, "resources">, "read"> | Listed<Property<D, "resources">, "write">;
+    { readonly entity: Entity } & { readonly [K in Listed<Property<D, "components">, "with"> & Component.Key]: Component<K> }
+    & { readonly [K in Exclude<Listed<Property<D, "components">, "optional">, Listed<Property<D, "components">, "with">> & Component.Key]: Component<K> | undefined };
 
 /**
- * Resources and lookups, each present only when declared, and the commands it issues for the next sync point: none on
- * another thread than the world's, which runs after the sync point.
+ * Every resource, its lookups when declared, and the commands it issues for the next sync point: none on another
+ * thread than the world's, which runs after the sync point and writes no resources.
  */
 export type Context<D extends Declaration | ChangesDeclaration> =
-    ([Resources<D>] extends [never] ? {} : {
-        readonly resources: Values<Listed<Property<D, "resources">, "read">, Listed<Property<D, "resources">, "write">, Resource.Key, ResourceValues>;
-    })
+    { readonly resources: WriteResources }
     & ([keyof Property<D, "lookup">] extends [never] ? {} : {
         readonly lookup: { readonly [K in keyof Property<D, "lookup">]: LookupFunction<Property<D, "lookup">[K]> };
     })
@@ -45,7 +46,7 @@ export type Group<C extends Component.Key> = {
 export type ChangeSet<C extends Component.Key> = {
     readonly groups: readonly Group<C>[];
     /** The value before the sync point, or null if the entity didn't have it. */
-    previous<K extends C>(entity: Entity, component: K): ReadonlyValue<K> | null;
+    previous<K extends C>(entity: Entity, component: K): ReadonlyType<K> | null;
     /** The value after it, or null if the entity won't have it. */
-    next<K extends C>(entity: Entity, component: K): ReadonlyValue<K> | null;
+    next<K extends C>(entity: Entity, component: K): ReadonlyType<K> | null;
 };

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

@@ -1,8 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../component/component.js";
-import { identify } from "../registry/ids.test-helper.js";
-import { labelOfItem, programFinalizers, programRules } from "../registry/index.js";
-import { Resource } from "../resource/resource.js";
+import { giveAccess, identify } from "../registry/ids.test-helper.js";
+import { programFinalizers, programRules } from "../registry/index.js";
 import { Rule } from "../rule/rule.js";
 import { clock } from "../resources/index.js";
 import { Finalizer } from "./finalizer.js";
@@ -33,116 +32,112 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(node, { thread: "main" });
-Component.register(label, { type: { type: "string" } });
-Component.register(tags, { type: { type: "array", items: { type: "string" } } });
-Component.register(slot, { type: { type: "number", default: 0 }, derived: true });
-Resource.register(total, { type: { type: "number", default: 0 }, reduce: "+" });
-Resource.register(time, { type: { type: "number", default: 0 } });
-Resource.register(page, { thread: "main" });
-Component.register(mark, { type: { const: true }, derived: true });
-Component.register(other, { type: { const: true }, derived: true });
 
-/** Declares as an untyped caller would, bypassing the types' checks. */
-const untyped = (constructor: (...parameters: never[]) => unknown, declaration: object): unknown => Reflect.apply(constructor, undefined, [declaration, () => {}]);
+/** Declares as an untyped caller would, bypassing the types' checks, its body using what `uses` says, as the build would infer. */
+const untyped = (constructor: (...parameters: never[]) => unknown, declaration: object, uses: Parameters<typeof giveAccess>[1] = {}): unknown =>
+    Reflect.apply(constructor, undefined, [giveAccess(declaration, uses), () => {}]);
 
 describe("Finalizer.create and Finalizer.changes", () => {
     it("record finalizers in creation order, keep the place of one declared again under its id with its new body, and reject its id with another declaration", () => {
-        const release = Finalizer.create(identify({ name: "typesFinalizerTest/release", components: { read: [node] } }, "f.ts#release"), () => {});
-        const save = Finalizer.changes({ name: "typesFinalizerTest/save", watch: [label] }, () => {});
+        const release = Finalizer.create(identify({ components: { with: [node] } }, "f.ts#release"), () => {});
+        const save = Finalizer.changes({ watch: [label] }, () => {});
         expect(programFinalizers().map(finalizer => finalizer.name)).toEqual([release.name, save.name]);
         const body = (): void => {};
-        expect(Finalizer.create(identify({ name: "typesFinalizerTest/release", components: { read: [node] } }, "f.ts#release"), body)).toBe(release);
+        // A body the build doesn't see is given what it uses.
+        expect(Finalizer.create(giveAccess(identify({ components: { with: [node] } }, "f.ts#release")), body)).toBe(release);
         expect(programFinalizers()[0]?.kind === "finalizer" ? programFinalizers()[0]?.body : null).toBe(body);
-        expect(() => Finalizer.create(identify({ name: "typesFinalizerTest/release", components: { read: [label] } }, "f.ts#release"), () => {})).toThrow("reload the page");
-        expect(() => Finalizer.changes(identify({ name: "typesFinalizerTest/release" }, "f.ts#release"), () => {})).toThrow("its id is a finalizer's");
+        expect(() => Finalizer.create(identify({ components: { with: [label] } }, "f.ts#release"), () => {})).toThrow("reload the page");
+        expect(() => Finalizer.changes(identify({}, "f.ts#release"), () => {})).toThrow("its id is a finalizer's");
         expect(programFinalizers()).toHaveLength(2);
     });
-    it("keep finalizers of one name apart, labeled apart", () => {
-        const first = Finalizer.changes({ name: "typesFinalizerTest/twin", watch: [label] }, () => {});
-        const second = Finalizer.changes({ name: "typesFinalizerTest/twin", watch: [label] }, () => {});
+    it("reject a body writing its row, which holds the values from before", () => {
+        expect(() => untyped(Finalizer.create, { components: { with: [label] } }, { write: [label] })).toThrow("which is read-only");
+    });
+    it("keep finalizers of one label apart", () => {
+        const twin = (): Finalizer => Finalizer.changes({ watch: [label] }, () => {});
+        const [first, second] = [twin(), twin()];
         expect(second).not.toBe(first);
-        expect([first, second].map(labelOfItem)).toEqual(["typesFinalizerTest/twin", "typesFinalizerTest/twin#2"]);
-        const third = Finalizer.changes({ name: "typesFinalizerTest/ordered", watch: [label], after: [second], before: [first] }, () => {});
+        expect([first.name, second.name]).toEqual(["twin", "twin"]);
+        const third = Finalizer.changes({ watch: [label], after: [second], before: [first] }, () => {});
         expect(programFinalizers().slice(-3)).toEqual([second, third, first]);
     });
     it("order finalizers by before and after, and reject a cycle or a resource conflict with no order", () => {
-        const late = Finalizer.create({ name: "typesFinalizerTest/late", components: { read: [label] }, resources: { read: [time] } }, () => {});
-        const early = Finalizer.create({ name: "typesFinalizerTest/early", components: { read: [label] }, resources: { write: [time] }, before: [late] }, () => {});
+        const late = Finalizer.create({ components: { with: [label] } }, (_, { resources }) => { void resources[time]; });
+        const early = Finalizer.create({ components: { with: [label] }, before: [late] }, (_, { resources }) => { resources[time] = 1; });
         expect(programFinalizers().map(finalizer => finalizer.name).filter(name => name === early.name || name === late.name)).toEqual([early.name, late.name]);
-        expect(() => Finalizer.create({ name: "typesFinalizerTest/conflict", components: { read: [label] }, resources: { read: [time] } }, () => {})).toThrow('both access "typesFinalizerTest/time", one writing it');
-        expect(() => Finalizer.create({ name: "typesFinalizerTest/cycle", components: { read: [label] }, before: [early], after: [late] }, () => {})).toThrow("ordered in a cycle");
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/clock", components: {}, resources: { write: [clock] } })).toThrow(`writes "clock", which only the world writes`);
+        expect(() => Finalizer.create({ components: { with: [label] } }, (_, { resources }) => { void resources[time]; })).toThrow('both access "typesFinalizerTest/time", one writing it');
+        expect(() => Finalizer.create({ components: { with: [label] }, before: [early], after: [late] }, () => {})).toThrow("ordered in a cycle");
+        expect(() => untyped(Finalizer.create, { components: {} }, { resources: { write: [clock] } })).toThrow(`writes "clock", which only the world writes`);
         expect(programFinalizers()).toHaveLength(7);
     });
     it("reject what types reject, for untyped callers", () => {
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/both", components: {}, resources: { read: [time], write: [time] } })).toThrow("in both resources read and write");
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/reduced", components: {}, resources: { write: [total] } })).toThrow("which is reduced");
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/span", components: { read: [node, tags] } })).toThrow('uses "typesFinalizerTest/node" on "main" and "typesFinalizerTest/tags" on "world"');
-        expect(() => untyped(Finalizer.changes, { name: "typesFinalizerTest/derived", watch: [slot] })).toThrow("which is derived");
-        expect(() => untyped(Finalizer.changes, { name: "typesFinalizerTest/resource", watch: [time] })).toThrow("which isn't a registered component");
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/hasResource", components: { has: [time] } })).toThrow(`Finalizer "typesFinalizerTest/hasResource" uses component "typesFinalizerTest/time", which isn't a registered component`);
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/lookupNot", components: { read: [label] }, lookup: { others: { not: [Symbol("typesFinalizerTest/unregistered")] } } })).toThrow("which isn't a registered component");
+        expect(() => untyped(Finalizer.create, { components: {} }, { resources: { write: [total] } })).toThrow("which is reduced");
+        expect(() => untyped(Finalizer.create, { components: {} }, { resources: { reduce: [total] } })).toThrow("only systems contribute to a reduction");
+        expect(() => untyped(Finalizer.create, { components: { with: [node, tags] } }, { read: [node, tags] })).toThrow('uses "typesFinalizerTest/node" on "main" and "typesFinalizerTest/tags" on "world"');
+        expect(() => untyped(Finalizer.changes, { name: "derived", watch: [slot] })).toThrow("which is derived");
+        expect(() => untyped(Finalizer.changes, { name: "resource", watch: [time] })).toThrow("which isn't a registered component");
+        expect(() => untyped(Finalizer.create, { components: { with: [time] } })).toThrow(`uses component "typesFinalizerTest/time", which isn't a registered component`);
+        expect(() => untyped(Finalizer.create, { components: { with: [label] }, lookup: { others: { not: [Symbol("typesFinalizerTest/unregistered")] } } }, { read: [label] })).toThrow("which isn't a registered component");
         expect(programFinalizers()).toHaveLength(7);
     });
     it("reject resource writes and lookups in a finalizer on another thread than the world's, and a changes finalizer watching or reading another thread's values", () => {
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/detachWriting", components: { read: [node] }, resources: { write: [time] } }))
-            .toThrow(`Finalizer "typesFinalizerTest/detachWriting" runs on thread "main" and writes resources; one on another thread than the world's runs after the sync point, so it writes none.`);
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/pageWriting", components: { read: [tags] }, resources: { write: [page] } }))
+        expect(() => untyped(Finalizer.create, { components: { with: [node] } }, { read: [node], resources: { write: [time] } }))
+            .toThrow(`runs on thread "main" and writes resources; one on another thread than the world's runs after the sync point, so it writes none.`);
+        expect(() => untyped(Finalizer.create, { components: { with: [tags] } }, { read: [tags], resources: { write: [page] } }))
             .toThrow('uses "typesFinalizerTest/tags" on "world" and "typesFinalizerTest/page" on "main"');
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/detachLooking", components: { read: [node] }, lookup: { labels: { read: [mark] } } }))
-            .toThrow(`Finalizer "typesFinalizerTest/detachLooking" runs on thread "main" and looks up other entities; one on another thread than the world's runs after the sync point, so it looks up none.`);
-        expect(() => untyped(Finalizer.changes, { name: "typesFinalizerTest/saveNodes", watch: [node] }))
-            .toThrow(`Finalizer "typesFinalizerTest/saveNodes" watches or reads values on thread "main"; a changes finalizer runs on the world's thread, in the sync point.`);
-        expect(() => untyped(Finalizer.changes, { name: "typesFinalizerTest/savePage", watch: [tags], resources: { read: [page] } }))
+        expect(() => untyped(Finalizer.create, { components: { with: [node] }, lookup: { labels: { with: [mark] } } }, { read: [node], lookup: { labels: [mark] } }))
+            .toThrow(`runs on thread "main" and looks up other entities; one on another thread than the world's runs after the sync point, so it looks up none.`);
+        expect(() => untyped(Finalizer.changes, { name: "saveNodes", watch: [node] }))
+            .toThrow(`watches or reads values on thread "main"; a changes finalizer runs on the world's thread, in the sync point.`);
+        expect(() => untyped(Finalizer.changes, { watch: [tags] }, { resources: { read: [page] } }))
             .toThrow('uses "typesFinalizerTest/tags" on "world" and "typesFinalizerTest/page" on "main"');
-        expect(() => untyped(Finalizer.changes, { name: "typesFinalizerTest/savePageOnly", resources: { read: [page] } }))
-            .toThrow(`Finalizer "typesFinalizerTest/savePageOnly" watches or reads values on thread "main"; a changes finalizer runs on the world's thread, in the sync point.`);
+        expect(() => untyped(Finalizer.changes, {}, { resources: { read: [page] } }))
+            .toThrow(`watches or reads values on thread "main"; a changes finalizer runs on the world's thread, in the sync point.`);
         // Reading another thread's values, without writing or looking up, it's created.
-        const detach = Finalizer.create({ name: "typesFinalizerTest/detach", components: { read: [node] }, resources: { read: [page] } }, () => {});
+        const detach = Finalizer.create({ components: { with: [node] } }, row => { void row[node]; });
         expect(programFinalizers()).toHaveLength(8);
         // Finalizers on different threads run at different times, so neither is ordered before the other.
-        const late = programFinalizers().find(finalizer => finalizer.name === "typesFinalizerTest/late");
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/afterDetach", components: { read: [label] }, after: [detach] }))
-            .toThrow(`Finalizer "typesFinalizerTest/afterDetach" runs on thread "world" and is ordered with "typesFinalizerTest/detach", which runs on thread "main"; finalizers on different threads run at different times, so neither is ordered before the other.`);
-        expect(() => untyped(Finalizer.create, { name: "typesFinalizerTest/beforeLate", components: { read: [node] }, before: [late] }))
-            .toThrow(`Finalizer "typesFinalizerTest/beforeLate" runs on thread "main" and is ordered with "typesFinalizerTest/late", which runs on thread "world"`);
-        expect(() => untyped(Finalizer.changes, { name: "typesFinalizerTest/saveAfterDetach", watch: [label], after: [detach] }))
-            .toThrow(`Finalizer "typesFinalizerTest/saveAfterDetach" runs on thread "world" and is ordered with "typesFinalizerTest/detach"`);
-        Finalizer.create({ name: "typesFinalizerTest/detachAgain", components: { read: [node] }, after: [detach] }, () => {});
+        const late = programFinalizers().find(finalizer => finalizer.name === "late");
+        expect(() => untyped(Finalizer.create, { components: { with: [label] }, after: [detach] }, { read: [label] }))
+            .toThrow(`runs on thread "world" and is ordered with "detach", which runs on thread "main"; finalizers on different threads run at different times, so neither is ordered before the other.`);
+        expect(() => untyped(Finalizer.create, { components: { with: [node] }, before: [late] }, { read: [node] }))
+            .toThrow(`runs on thread "main" and is ordered with "late", which runs on thread "world"`);
+        expect(() => untyped(Finalizer.changes, { name: "saveAfterDetach", watch: [label], after: [detach] }))
+            .toThrow(`runs on thread "world" and is ordered with "detach"`);
+        Finalizer.create({ components: { with: [node] }, after: [detach] }, row => { void row[node]; });
         expect(programFinalizers()).toHaveLength(9);
     });
 });
 
 describe("Rule.create", () => {
     it("records a rule and returns it, the one already recorded when declared again under its id, and rejects its id with another declaration", () => {
-        const slots = Rule.create(identify({ name: "typesFinalizerTest/slots", components: { has: [label] }, derive: [slot] }, "r.ts#slots"));
+        const slots = Rule.create(identify({ components: { with: [label] }, derive: [slot] }, "r.ts#slots"));
         expect(programRules()).toEqual([slots]);
-        expect(Rule.create(identify({ name: "typesFinalizerTest/slots", components: { has: [label] }, derive: [slot] }, "r.ts#slots"))).toBe(slots);
-        expect(() => Rule.create(identify({ name: "typesFinalizerTest/slots", components: { has: [node] }, derive: [slot] }, "r.ts#slots"))).toThrow("reload the page");
-        const twin = Rule.create({ name: "typesFinalizerTest/slots", components: { has: [node] }, derive: [slot] });
+        expect(Rule.create(identify({ components: { with: [label] }, derive: [slot] }, "r.ts#slots"))).toBe(slots);
+        expect(() => Rule.create(identify({ components: { with: [node] }, derive: [slot] }, "r.ts#slots"))).toThrow("reload the page");
+        const twin = Rule.create({ components: { with: [node] }, derive: [slot] });
         expect(programRules()).toEqual([slots, twin]);
-        expect([slots, twin].map(labelOfItem)).toEqual(["typesFinalizerTest/slots (r.ts#slots)", "typesFinalizerTest/slots#2"]);
+        expect([slots, twin].map(rule => rule.name)).toEqual(["slots", "twin"]);
     });
     it("rejects rules that derive in a cycle through a negation", () => {
-        Rule.create({ name: "typesFinalizerTest/marks", components: { not: [mark] }, derive: [other] });
-        expect(() => Rule.create({ name: "typesFinalizerTest/others", components: { has: [other] }, derive: [mark] })).toThrow("cycle through a negation");
+        Rule.create({ components: { not: [mark] }, derive: [other] });
+        expect(() => Rule.create({ components: { with: [other] }, derive: [mark] })).toThrow("cycle through a negation");
         expect(programRules()).toHaveLength(3);
     });
     it("rejects a rule deriving a component that isn't derived, or matching on a resource", () => {
         const create = (declaration: object): unknown => Reflect.apply(Rule.create, undefined, [declaration]);
-        expect(() => create({ name: "typesFinalizerTest/essential", components: {}, derive: [label] })).toThrow("which isn't declared derived");
-        expect(() => create({ name: "typesFinalizerTest/onResource", components: { has: [time] }, derive: [slot] })).toThrow("which isn't a registered component");
+        expect(() => create({ components: {}, derive: [label] })).toThrow("which isn't declared derived");
+        expect(() => create({ components: { with: [time] }, derive: [slot] })).toThrow("which isn't a registered component");
         expect(programRules()).toHaveLength(3);
     });
 });
 
-describe("rules and finalizers without a name", () => {
-    it("are named by their binding and id, or else by their kind numbered", () => {
-        const rule = Rule.create(identify({ components: { has: [node] }, derive: [slot] }, "rules.ts#slotted"));
-        const release = Finalizer.create(identify({ components: { read: [node] } }, "finalizers.ts#release"), () => {});
-        expect([rule, release].map(labelOfItem)).toEqual(["slotted (rules.ts#slotted)", "release (finalizers.ts#release)"]);
-        const labels = [Rule.create({ components: { has: [label] }, derive: [slot] }), Finalizer.changes({ watch: [label] }, () => {})].map(labelOfItem);
-        expect(labels.map(found => found.replace(/#\d+$/, "#n"))).toEqual(["rule #n", "finalizer #n"]);
+describe("rules' and finalizers' labels", () => {
+    it("are the bindings of their ids, or else their kinds numbered", () => {
+        const [rule, release] = [Rule.create(identify({ components: { with: [node] }, derive: [slot] }, "rules.ts#slotted")), Finalizer.create(identify({ components: { with: [node] } }, "finalizers.ts#release"), () => {})];
+        expect([rule?.name, release?.name]).toEqual(["slotted", "release"]);
+        // Made in an expression no binding names, so the build labels them by nothing.
+        const [rule2, finalizer2] = [Rule.create({ components: { with: [label] }, derive: [slot] }), Finalizer.changes({ watch: [label] }, () => {})];
+        expect([rule2, finalizer2].map(item => item.name.replace(/#\d+$/, "#n"))).toEqual(["rule #n", "finalizer #n"]);
     });
 });