@adobe/ecs 0.1.0 → 0.2.1

package/src/interface/resource/written.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { clock } from '../resources/clock.js';
 
 /** Resources only the world writes: systems and finalizers read them, and worlds don't start them at other values. */

package/src/interface/resources/always.ts

@@ -1,4 +1,5 @@
-import { Resource } from '../resource/resource.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { registerResource } from '../registry/declarations.js';
 
 /** Whether every beat of the cadence runs a tick, not only beats where `wake` is due or a run arrived. False by default. */
 export const always = Symbol("always");
@@ -9,4 +10,4 @@ declare module '@adobe/ecs' {
     }
 }
 
-Resource.register(always, { type: { type: "boolean", default: false } });
+registerResource(always, { type: { type: "boolean" }, default: false });

package/src/interface/resources/cadence.ts

@@ -1,6 +1,7 @@
-import { Resource } from '../resource/resource.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { registerResource } from '../registry/declarations.js';
 
-/** The cadence's value, for the implementation: `Resource.Value<typeof cadence>`. */
+/** The cadence's value, for the implementation: `Resource<typeof cadence>`. */
 export type Cadence = { readonly kind: "frame" } | { readonly kind: "fixed"; readonly step: number; readonly maxSteps?: number };
 
 /**
@@ -16,12 +17,12 @@ declare module '@adobe/ecs' {
     }
 }
 
-Resource.register(cadence, {
+registerResource(cadence, {
     type: {
         anyOf: [
             { type: "object", properties: { kind: { const: "frame" } } },
             { type: "object", properties: { kind: { const: "fixed" }, step: { type: "number", minimum: 0 }, maxSteps: { type: "integer", minimum: 1 } }, required: ["kind", "step"] },
         ],
-        default: { kind: "frame" },
     },
+    default: { kind: "frame" },
 });

package/src/interface/resources/clock.ts

@@ -1,4 +1,5 @@
-import { Resource } from '../resource/resource.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { registerResource } from '../registry/declarations.js';
 
 /**
  * The current tick, written only by the world before each tick: `now`, the beat's time in milliseconds, `delta`, the
@@ -12,6 +13,7 @@ declare module '@adobe/ecs' {
     }
 }
 
-Resource.register(clock, {
-    type: { type: "object", properties: { now: { type: "number" }, delta: { type: "number" }, tick: { type: "number" } }, default: { now: 0, delta: 0, tick: 0 } },
+registerResource(clock, {
+    type: { type: "object", properties: { now: { type: "number" }, delta: { type: "number" }, tick: { type: "number" } } },
+    default: { now: 0, delta: 0, tick: 0 },
 });

package/src/interface/resources/gpu-device.ts

@@ -1,4 +1,5 @@
-import { Resource } from '../resource/resource.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { registerResource } from '../registry/declarations.js';
 
 /**
  * The device the world's GPU storage lives on, for both `kernel: "gpu"` kernels and render systems, or null for a world
@@ -13,4 +14,4 @@ declare module '@adobe/ecs' {
     }
 }
 
-Resource.register(gpuDevice, {});
+registerResource(gpuDevice, {});

package/src/interface/resources/index.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 export * from './always.js';
 export { cadence } from './cadence.js';
 export * from './clock.js';

package/src/interface/resources/wake.ts

@@ -1,4 +1,5 @@
-import { Resource } from '../resource/resource.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { registerResource } from '../registry/declarations.js';
 
 /**
  * The earliest `clock.now`, in milliseconds, at which a system asked for the next tick, by contributing to it; Infinity
@@ -12,4 +13,4 @@ declare module '@adobe/ecs' {
     }
 }
 
-Resource.register(wake, { type: { type: "number", default: Infinity }, reduce: "min" });
+registerResource(wake, { type: { type: "number" }, reduce: "min", default: Infinity });

package/src/interface/resources/workers.ts

@@ -1,4 +1,5 @@
-import { Resource } from '../resource/resource.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { registerResource } from '../registry/declarations.js';
 
 /** The kernel pool's size, 0 for none, or `null`, the default, for the platform's choice. The pool follows it at sync points. */
 export const workers = Symbol("workers");
@@ -9,4 +10,4 @@ declare module '@adobe/ecs' {
     }
 }
 
-Resource.register(workers, { type: { anyOf: [{ type: "integer", minimum: 0 }, { type: "null" }], default: null } });
+registerResource(workers, { type: { anyOf: [{ type: "integer", minimum: 0 }, { type: "null" }] }, default: null });

package/src/interface/rule/create.ts

@@ -1,4 +1,5 @@
-import { declarationOf, kindOf, labelOf } from '../registry/names.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { declarationOf, kindOf, labelOf, whyUnregistered } from '../registry/names.js';
 import { takeIdOfDeclaration } from '../registry/ids.js';
 import { nameOf } from '../registry/items.js';
 import { addRule } from '../registry/program.js';
@@ -6,20 +7,21 @@ import type { Rule as Created } from './created.js';
 import type { Declaration } from './declaration.js';
 
 /**
- * Declares a rule, which applies in every world, and returns it: identified by that value, labeled by its name. Throws
+ * Declares a rule, which applies in every world, and returns it: identified by that value, labeled by its binding. Throws
  * if it matches on a key that isn't a registered component, derives a component that isn't derived, or derives in a
  * cycle through a negation.
  */
-export const create = <const D extends Declaration>(declaration: D): { readonly name: string } => {
+export const create = <const D extends Declaration>(declaration: D & { readonly components: { readonly has?: never } }): { readonly name: string } => {
     const id = takeIdOfDeclaration(declaration);
-    const name = nameOf(declaration.name, id, "rule");
-    const { components, derive } = declaration;
+    const name = nameOf(declaration, id, "rule");
+    const { derive } = declaration;
+    const components = { has: declaration.components.with, not: declaration.components.not };
     for (const key of [...components.has ?? [], ...components.not ?? [], ...derive]) {
-        if (kindOf(key) !== "component") throw new Error(`Rule "${name}" uses "${labelOf(key)}", which isn't a registered component.`);
+        if (kindOf(key) !== "component") throw new Error(`Rule "${name}" uses "${labelOf(key)}", which isn't a registered component: ${whyUnregistered(key)}.`);
     }
     for (const key of derive) {
         if (declarationOf(key)?.derived !== true) throw new Error(`Rule "${name}" derives "${labelOf(key)}", which isn't declared derived.`);
     }
-    const rule: Created<D> = { kind: "rule", name, declaration };
+    const rule: Created = { kind: "rule", name, declaration: { ...declaration, components } };
     return addRule(rule, id);
 };

package/src/interface/rule/created.ts

@@ -1,4 +1,5 @@
-import type { Declaration } from './declaration.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Stored } from './declaration.js';
 
 /** A rule: entities matching its components have the components it derives. */
-export type Rule<D extends Declaration = Declaration> = { readonly kind: "rule"; readonly name: string; readonly declaration: D };
+export type Rule = { readonly kind: "rule"; readonly name: string; readonly declaration: Stored };

package/src/interface/rule/declaration.ts

@@ -1,11 +1,15 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Component } from '../component/component.js';
-import type { Name } from './name.js';
 import type { Derived } from '../component/value.js';
 
 export type Declaration = {
-    readonly name?: Name;
     /** Which entities the rule matches, by the components they have and don't have. */
-    readonly components: { readonly has?: readonly Component.Key[]; readonly not?: readonly Component.Key[] };
+    readonly components: { readonly with?: readonly Component.Key[]; readonly not?: readonly Component.Key[] };
     /** Components present on matching entities, while any rule deriving them matches. */
     readonly derive: readonly Derived[];
 };
+
+/** A rule's declaration as the world takes it: what it requires in `has`. */
+export type Stored = Omit<Declaration, "components"> & {
+    readonly components: { readonly has?: readonly symbol[]; readonly not?: readonly symbol[] };
+};

package/src/interface/rule/index.ts

@@ -1 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 export * from './create.js';

package/src/interface/rule/rule.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 export type Rule = never;
 
 export * as Rule from './index.js';

package/src/interface/rule/rule.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 { Entity } from '../entity/entity.js';
@@ -29,20 +30,14 @@ declare module '@adobe/ecs' {
         [time]: { type: number };
     }
 }
-Component.register(source, { type: { type: "number" } });
-Component.register(hidden, { type: { const: true } });
-Component.register(slot, { type: { type: "number", default: 0 }, derived: true });
-Component.register(parent, { type: Entity.schema, reference: "owner" });
-Resource.register(time, { type: { type: "number", default: 0 } });
 
 // Rules derive only derived components.
-const slots = Rule.create({ name: "ruleTypeTest/slots", components: { has: [source], not: [hidden] }, derive: [slot] });
+const slots = Rule.create({ components: { with: [source], not: [hidden] }, derive: [slot] });
 // @ts-expect-error a rule derives only derived components
-Rule.create({ name: "ruleTypeTest/slots", components: { has: [source] }, derive: [source] });
+Rule.create({ components: { with: [source] }, derive: [source] });
 
-// A finalizer's context holds only what it declares, and its commands.
-const other = Finalizer.create({ name: "ruleTypeTest/other", components: { read: [source] } }, (_, context) => {
-    // @ts-expect-error no resources declared
+// A finalizer's context holds every resource, the lookups it declares, and its commands.
+const other = Finalizer.create({ components: { with: [source] } }, (_, context) => {
     void context.resources;
     // @ts-expect-error no lookups declared
     void context.lookup;
@@ -51,9 +46,7 @@ const other = Finalizer.create({ name: "ruleTypeTest/other", components: { read:
 
 // Per-query finalizers read the stopping row; it's read-only.
 Finalizer.create({
-    name: "ruleTypeTest/release",
-    components: { read: [slot, parent], not: [hidden] },
-    resources: { read: [time] },
+    components: { with: [slot, parent], not: [hidden] },
     after: [other],
 }, (row, { resources, commands }) => {
     const value: number = row[slot];
@@ -62,21 +55,16 @@ Finalizer.create({
     commands.despawn(target);
     // @ts-expect-error a finalizer's row is read-only
     row[slot] = 1;
-    // @ts-expect-error only declared reads are in the row
+    // @ts-expect-error only what with requires is in the row
     void row[source];
-    // @ts-expect-error read resources are read-only
-    resources[time] = 0;
     void value; void now;
 });
 Finalizer.create({
-    name: "ruleTypeTest/other",
     components: {},
-    // @ts-expect-error write already makes a resource readable
-    resources: { read: [time], write: [time] },
 }, () => {});
 
 // Changes finalizers see only the essential components they watch.
-Finalizer.changes({ name: "ruleTypeTest/save", watch: [source, parent] }, (changes, { commands }) => {
+Finalizer.changes({ watch: [source, parent] }, (changes, { commands }) => {
     check<Equal<typeof changes, ChangeSet<typeof source | typeof parent>>>();
     void commands;
     for (const group of changes.groups) {
@@ -91,19 +79,21 @@ Finalizer.changes({ name: "ruleTypeTest/save", watch: [source, parent] }, (chang
     }
 });
 // @ts-expect-error changes finalizers don't watch derived components
-Finalizer.changes({ name: "ruleTypeTest/save", watch: [slot] }, () => {});
+Finalizer.changes({ watch: [slot] }, () => {});
 
 // References change only through commands, so systems can't write them.
-System.create({ name: "ruleTypeTest/move", components: { read: [parent], write: [source] } }, row => { row[source] = row[parent]; });
-// @ts-expect-error a reference changes only through commands
-System.create({ name: "ruleTypeTest/move", components: { write: [parent] } }, () => {});
+System.create({ components: { with: [parent, source] } }, row => { row[source] = row[parent]; });
+System.create({ components: { with: [parent] } }, row => {
+    // @ts-expect-error a reference changes only through commands
+    row[parent] = row.entity;
+});
 check<Equal<Extract<Writable, typeof parent | typeof source>, typeof source>>();
 
 // A rule and a finalizer are the values their constructors return, labeled by their names, which needn't be unique.
 check<Equal<typeof slots, ReturnType<typeof Rule.create>>>();
 check<Equal<typeof slots, { readonly name: string }>>();
 check<Equal<typeof other, Finalizer>>();
-const sameName: Finalizer = Finalizer.create({ name: "ruleTypeTest/other", components: { read: [source] } }, () => {});
+const sameName: Finalizer = Finalizer.create({ components: { with: [source] } }, () => {});
 void sameName;
 
 // Rules and finalizers apply in every world.
@@ -111,7 +101,7 @@ declare const create: Create;
 export const created: World = create();
 
 // Names are optional for rules and finalizers too.
-const unnamedRule = Rule.create({ components: { has: [source] }, derive: [slot] });
-const unnamedFinalizer: Finalizer = Finalizer.create({ components: { read: [source] } }, row => { void row[source]; });
+const unnamedRule = Rule.create({ components: { with: [source] }, derive: [slot] });
+const unnamedFinalizer: Finalizer = Finalizer.create({ components: { with: [source] } }, row => { void row[source]; });
 const unnamedChanges: Finalizer = Finalizer.changes({ watch: [source] }, changes => { void changes.groups; });
 void [unnamedRule, unnamedFinalizer, unnamedChanges];

package/src/interface/schema/is-struct.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 type Method = (...parameters: never[]) => unknown;
 
 /** Whether an object type has a method of its own, so it isn't data, looked at without recursing. */
@@ -14,6 +15,17 @@ export type IsStruct<T> =
     [T] extends [object] ? (HasMethod<T> extends true ? false : false extends { [K in keyof T]-?: IsStruct<T[K]> }[keyof T] ? false : true) :
     false;
 
+/**
+ * Whether a value is comparable data, which a shared component holds: numbers, booleans, strings, arrays and plain
+ * objects of those, compared by structure. Not `null`, maps, sets, functions or objects with methods.
+ */
+export type IsComparable<T> =
+    [T] extends [number | boolean | string] ? true :
+    [T] extends [Method] ? false :
+    [T] extends [readonly unknown[]] ? IsComparable<T[number]> :
+    [T] extends [object] ? (HasMethod<T> extends true ? false : false extends { [K in keyof T]-?: IsComparable<T[K]> }[keyof T] ? false : true) :
+    false;
+
 /** Whether a value is a string, a union of string literals or a string or `null`. */
 export type IsString<T> = [T] extends [null] ? false : [T] extends [string | null] ? true : false;
 

package/src/interface/schema/schema.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Entity } from '../entity/entity.js';
 
 /** Any value representable in JSON. */
@@ -16,12 +17,14 @@ interface ObjectSchema<K extends string = string> {
     readonly properties: { readonly [P in K]: Schema };
     readonly required?: readonly K[];
     readonly layout?: GpuLayout;
+    readonly default?: never;
 }
 
 interface StringSchema {
     readonly type: 'string';
     readonly minLength?: number;
     readonly maxLength?: number;
+    readonly default?: never;
 }
 
 interface ArraySchema<T extends Schema> {
@@ -30,6 +33,7 @@ interface ArraySchema<T extends Schema> {
     readonly layout?: GpuLayout;
     readonly minItems?: number;
     readonly maxItems?: number;
+    readonly default?: never;
 }
 
 interface NumberSchema {
@@ -37,12 +41,14 @@ interface NumberSchema {
     readonly minimum?: number;
     readonly maximum?: number;
     readonly precision?: 1 | 2;
+    readonly default?: never;
 }
 
 /** An entity reference, typed `Entity`. Every entity-typed value uses it, so references can be found by schema. */
 interface EntitySchema {
     readonly type: 'integer';
     readonly format: 'entity';
+    readonly default?: never;
 }
 
 interface IntegerSchema {
@@ -50,20 +56,24 @@ interface IntegerSchema {
     readonly format?: never;
     readonly minimum?: number;
     readonly maximum?: number;
+    readonly default?: never;
 }
 
 interface BooleanSchema {
     readonly type: 'boolean';
+    readonly default?: never;
 }
 
 interface NullSchema {
     readonly type: 'null';
+    readonly default?: never;
 }
 
 /** A `ReadonlySet` of `items`' values. JSON has no set, so `'set'` isn't a JSON Schema type. */
 interface SetSchema<T extends Schema> {
     readonly type: 'set';
     readonly items: T;
+    readonly default?: never;
 }
 
 /** A `ReadonlyMap` from `keys`' values to `values`' values. JSON has no map, so `'map'` isn't a JSON Schema type. */
@@ -71,6 +81,7 @@ interface MapSchema<K extends Schema, V extends Schema> {
     readonly type: 'map';
     readonly keys: K;
     readonly values: V;
+    readonly default?: never;
 }
 
 /** Matches exactly one JSON value of any shape. */
@@ -78,19 +89,23 @@ interface ConstSchema {
     /** The value alone fully describes the schema; combining it with `type` is redundant and disallowed. */
     readonly type?: never;
     readonly const: JSONValue;
+    readonly default?: never;
 }
 
 interface AndSchema {
     readonly allOf: readonly Schema[];
+    readonly default?: never;
 }
 
 interface OrSchema {
     readonly anyOf: readonly Schema[];
+    readonly default?: never;
 }
 
 /**
  * A JSON Schema of the forms the ECS reads, and two forms JSON lacks: `{ type: 'set', items }` and
- * `{ type: 'map', keys, values }`.
+ * `{ type: 'map', keys, values }`. A schema describes values and holds no `default`: a value's start comes from its
+ * declaration or its type's namespace, `T.default`.
  */
 export type Schema = EntitySchema | ObjectSchema | StringSchema | ArraySchema<Schema> | NumberSchema | IntegerSchema | BooleanSchema | NullSchema | SetSchema<Schema> | MapSchema<Schema, Schema> | ConstSchema | AndSchema | OrSchema;
 
@@ -139,6 +154,13 @@ export namespace Schema {
         T extends NullSchema ? null :
         never;
 
+    /**
+     * The type schema `S` describes, as a plain type: `type Level = Schema.Type<{ type: "integer"; minimum: 0; maximum: 9 }>`
+     * is a `number`. Declarations naming such a type, directly or through aliases, get `S` as their schema from the
+     * build, so a named type carries its precision, width and bounds.
+     */
+    export type Type<S extends Schema> = ToType<S>;
+
     /** The schemas whose `ToType` is `T`; constrains a schema to describe a known type. */
     export type ForType<T> = Schema &
     (

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

@@ -1,4 +1,4 @@
-import type { IsData } from "./is-data.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { IsStruct } from "./is-struct.js";
 import type { Schema } from "./schema.js";
 
@@ -134,20 +134,22 @@ const badSetForm: Schema = { type: 'set', keys: { type: 'string' }, values: { ty
 const badMapForm: Schema = { type: 'map', items: { type: 'string' } };
 void [okSet, okMap, badSet, badMap, badSetForm, badMapForm];
 
-// A ReadonlySet or ReadonlyMap of data is data; a Set or Map, which changes in place, isn't, nor one holding functions.
-check<Equal<IsData<ReadonlySet<string>>, true>>();
-check<Equal<IsData<ReadonlyMap<string, { readonly x: number }>>, true>>();
-check<Equal<IsData<ReadonlySet<() => void>>, false>>();
-check<Equal<IsData<Set<string>>, false>>();
-check<Equal<IsData<Map<string, number>>, false>>();
-// An object is data only when every member is: a record of handles isn't, however deep they are.
-check<Equal<IsData<{ readonly context: GPUCanvasContext; readonly canvas: HTMLCanvasElement }>, false>>();
-check<Equal<IsData<{ readonly pipelines: { readonly fill: GPURenderPipeline } }>, false>>();
-check<Equal<IsData<{ readonly items: readonly { readonly blob: Blob }[] }>, false>>();
-check<Equal<IsData<{ readonly at: readonly [number, number]; readonly label?: string; readonly nested: { readonly x: number } }>, true>>();
-// A recursive data type is still data.
-type Tree = { readonly value: number; readonly children: readonly Tree[] };
-check<Equal<IsData<Tree>, true>>();
-// Neither is a struct: neither lives in shared memory.
+// A set or map isn't a struct: neither lives in shared memory.
 check<Equal<IsStruct<ReadonlySet<number>>, false>>();
 check<Equal<IsStruct<ReadonlyMap<number, number>>, false>>();
+
+// Schema.Type is the plain type a schema describes, so a type named by it is that type: a number or a tuple, unbranded.
+type Level = Schema.Type<{ type: "integer"; minimum: 0; maximum: 9 }>;
+check<Equal<Level, number>>();
+check<Equal<Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }>, readonly [number, number, number]>>();
+// @ts-expect-error its argument is a schema
+type NotSchema = Schema.Type<{ type: "integer"; minimum: "zero" }>;
+
+// A schema holds no default, anywhere: a value's start comes from its declaration or its type's namespace.
+// @ts-expect-error a default isn't part of a schema
+const badDefault: Schema = { type: 'number', default: 0 };
+// @ts-expect-error nor of a field's schema
+const badFieldDefault: Schema = { type: 'object', properties: { x: { type: 'number', default: 0 } } };
+// @ts-expect-error Schema.Type takes a schema, so a default fails there too
+type BadType = Schema.Type<{ type: 'integer'; minimum: 1; default: 5 }>;
+void [badDefault, badFieldDefault];

package/src/interface/schema/schemas.type-test.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Schema } from "./schema.js";
 
 const ok: Schema.ForType<true> = { const: true };

package/src/interface/system/access.ts

@@ -1,37 +1,43 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Component } from '../component/component.js';
 import type { Resource } from '../resource/resource.js';
-import type { Writable } from '../component/value.js';
 import type { Condition } from '../resource/condition.js';
-import type { Reduced } from '../resource/reduction.js';
-import type { WorldWritten } from '../resource/written.js';
 import type { Index } from '../indexes/index-type.js';
+import type { Shared } from '../component/value.js';
+import type { ReadResources } from './body.js';
 
 /**
- * Matches every component in `read`, `write`, `has`, `added` and `changed`, and excludes `not`. A component in `write`
- * is also readable, so it's never listed in `read` as well.
+ * The entities a system runs over: those with every component in `with`, `added` and `changed`, and none in `not`.
+ * What its body reads and writes of them the build infers from the body.
  */
 export type ComponentAccess = {
-    readonly read?: readonly Component.Key[];
-    /** A component holding a `reference` changes only through commands, so it can't be written here. */
-    readonly write?: readonly Writable[];
-    readonly has?: readonly Component.Key[];
+    readonly with?: readonly Component.Key[];
+    /** Components its rows hold where an entity has them, `undefined` where it doesn't; they never narrow what it matches. */
+    readonly optional?: readonly Component.Key[];
     readonly not?: readonly Component.Key[];
     /** Passes rows where any of these were added since the system last ran. */
     readonly added?: readonly Component.Key[];
     /** Passes rows where any of these may have changed since the system last ran. */
     readonly changed?: readonly Component.Key[];
+    /**
+     * Keeps the system to the archetypes whose shared components' values pass, each one required as `with` requires
+     * it: a value passes the archetypes holding an equal one, a predicate those it returns true for. A predicate reads
+     * its value and the world's resources, never anything else that may change, and runs as written on the thread
+     * that runs the system, once per archetype as it appears and again whenever a resource it reads changed. With
+     * change filters, an archetype it skipped keeps its rows unseen until it passes again.
+     */
+    readonly where?: { readonly [K in Shared]?: Component<K> | ((value: Component<K>, context: { readonly resources: ReadResources }) => boolean) };
 };
 
 /**
- * Read-only access to other entities: by entity, matching `read`, `has` and `not`, or through an index by key. A lookup
- * by entity's `changed` names components it reads or has, whose changes its row's `changed` reports. An index lookup's
- * `read` names components every entity the index holds has, its key parts or its `has`, and its `changed` the ones
- * whose changes its lists' `changed` reports. Both report as a system's `changed` filter does; its system can't write a
- * key part or what it reads.
+ * Read-only access to other entities: by entity, matching `with` and `not`, its `optional` components read where an
+ * entity has them, or through an index by key, whose rows hold what every entity the index holds has. What the body reads of them the build infers. A lookup by entity's
+ * `changed` names components in `with`, whose changes its row's `changed` reports, and an index lookup's those of its
+ * rows. Both report as a system's `changed` filter does; its system can't write a key part or what it reads.
  */
 export type Lookup =
-    | Pick<ComponentAccess, "read" | "has" | "not"> & { readonly changed?: readonly Component.Key[] }
-    | { readonly index: Index; readonly read?: readonly Component.Key[]; readonly changed?: readonly Component.Key[] };
+    | { readonly with?: readonly Component.Key[]; readonly optional?: readonly Component.Key[]; readonly not?: readonly Component.Key[]; readonly changed?: readonly Component.Key[]; readonly index?: never }
+    | { readonly index: Index; readonly changed?: readonly Component.Key[]; readonly with?: never; readonly optional?: never; readonly not?: never };
 
 /**
  * A system's lookup. An index lookup's `changed: true` makes the index a change filter, as a resource in `changed` is:
@@ -40,24 +46,17 @@ export type Lookup =
  * when a condition fails, keeping its `lastRun`. Its lists' `changed` then reports those changes alone. Only on the
  * world's thread.
  */
-export type SystemLookup =
-    | Lookup
-    | { readonly index: Index; readonly read?: readonly Component.Key[]; readonly changed: true };
+export type SystemLookup = Lookup | { readonly index: Index; readonly changed: true };
 
 /**
  * The parent each row's values flow down from: the entity its `through` reference names, read before the row. Rows
- * run parent first, so a parent's value is the one written earlier in the same run, and `read` may name components the
- * system writes.
+ * run parent first, so a parent's value is the one written earlier in the same run. The context's `up` holds the
+ * parent's values the body reads, or null for a row without a parent or whose parent lacks one of them.
  */
-export type Up = { readonly through: Component.With<"reference">; readonly read?: readonly Component.Key[] };
+export type Up = { readonly through: Component.With<"reference"> };
 
-/**
- * A resource in `write` is also readable, so it's never listed in `read` as well. Reduced resources are never written,
- * nor are those only the world writes.
- */
+/** The resources a system filters and is conditioned on; what its body reads, writes and reduces the build infers. */
 export type ResourceAccess = {
-    readonly read?: readonly Resource.Key[];
-    readonly write?: readonly Exclude<Resource.Key, Reduced | WorldWritten>[];
     /** Passes every row when any of these changed since the system last ran. */
     readonly changed?: readonly Resource.Key[];
     /** Runs only while each of these is neither `null` nor `false`, and reads it as such. Otherwise it's skipped, successfully. */
@@ -65,3 +64,44 @@ export type ResourceAccess = {
     /** Runs only while each of these is `null` or `false`. Otherwise it's skipped, successfully. */
     readonly not?: readonly Condition[];
 };
+
+/** A key, as the world takes declarations: their lists come from the build, untyped. */
+type Key = symbol;
+
+/**
+ * What a system reads and writes, as the world takes it: the build's inferred access joined with its declaration.
+ * Matches every component in `read`, `write`, `has`, `added` and `changed` but those in `optional`, and excludes `not`.
+ */
+export type ComponentLists = {
+    /** Members its rows hold only where an entity has them; those it uses are in `read` or `write` too. */
+    readonly optional?: readonly Key[];
+    readonly read?: readonly Key[];
+    readonly write?: readonly Key[];
+    readonly has?: readonly Key[];
+    readonly not?: readonly Key[];
+    readonly added?: readonly Key[];
+    readonly changed?: readonly Key[];
+    /** Its `where`, by shared component: a value, or a predicate of it and the resources. Its keys are in `has` or `read`. */
+    readonly where?: { readonly [key: symbol]: unknown };
+    /** The resources its `where`'s predicates read, which the build infers: when one changed, they're evaluated again. */
+    readonly whereReads?: readonly Key[];
+};
+
+/** A lookup as the world takes it, with what its body reads of its rows in `read`. */
+export type LookupLists =
+    | { readonly read?: readonly Key[]; readonly has?: readonly Key[]; readonly optional?: readonly Key[]; readonly not?: readonly Key[]; readonly changed?: readonly Key[] }
+    | { readonly index: Index; readonly read?: readonly Key[]; readonly changed?: readonly Key[] };
+
+export type SystemLookupLists = LookupLists | { readonly index: Index; readonly read?: readonly Key[]; readonly changed: true };
+
+export type UpLists = { readonly through: Key; readonly read?: readonly Key[] };
+
+/** A system's resources as the world takes them. */
+export type ResourceLists = {
+    readonly read?: readonly Key[];
+    readonly write?: readonly Key[];
+    readonly reduce?: readonly Key[];
+    readonly changed?: readonly Key[];
+    readonly is?: readonly Key[];
+    readonly not?: readonly Key[];
+};