@adobe/ecs 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,6 @@
+export * from './always.js';
+export { cadence } from './cadence.js';
+export * from './clock.js';
+export * from './gpu-device.js';
+export * from './wake.js';
+export * from './workers.js';

package/dist/interface/resources/index.js

@@ -0,0 +1,7 @@
+export * from './always.js';
+export { cadence } from './cadence.js';
+export * from './clock.js';
+export * from './gpu-device.js';
+export * from './wake.js';
+export * from './workers.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interface/resources/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC"}

package/dist/interface/resources/wake.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The earliest `clock.now`, in milliseconds, at which a system asked for the next tick, by contributing to it; Infinity
+ * for none. The first beat at or after it runs a tick.
+ */
+export declare const wake: unique symbol;
+declare module '@adobe/ecs' {
+    interface Resources {
+        [wake]: {
+            type: number;
+            reduce: "min";
+        };
+    }
+}

package/dist/interface/resources/wake.js

@@ -0,0 +1,8 @@
+import { Resource } from '../resource/resource.js';
+/**
+ * The earliest `clock.now`, in milliseconds, at which a system asked for the next tick, by contributing to it; Infinity
+ * for none. The first beat at or after it runs a tick.
+ */
+export const wake = Symbol("wake");
+Resource.register(wake, { type: { type: "number", default: Infinity }, reduce: "min" });
+//# sourceMappingURL=wake.js.map

package/dist/interface/resources/wake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wake.js","sourceRoot":"","sources":["../../../src/interface/resources/wake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD;;;GAGG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;AAQnC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC"}

package/dist/interface/resources/workers.d.ts

@@ -0,0 +1,9 @@
+/** 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 declare const workers: unique symbol;
+declare module '@adobe/ecs' {
+    interface Resources {
+        [workers]: {
+            type: number | null;
+        };
+    }
+}

package/dist/interface/resources/workers.js

@@ -0,0 +1,5 @@
+import { Resource } from '../resource/resource.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");
+Resource.register(workers, { type: { anyOf: [{ type: "integer", minimum: 0 }, { type: "null" }], default: null } });
+//# sourceMappingURL=workers.js.map

package/dist/interface/resources/workers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workers.js","sourceRoot":"","sources":["../../../src/interface/resources/workers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,iIAAiI;AACjI,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;AAQzC,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC"}

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

@@ -0,0 +1,9 @@
+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
+ * 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 declare const create: <const D extends Declaration>(declaration: D) => {
+    readonly name: string;
+};

package/dist/interface/rule/create.js

@@ -0,0 +1,25 @@
+import { declarationOf, kindOf, labelOf } from '../registry/names.js';
+import { takeIdOfDeclaration } from '../registry/ids.js';
+import { nameOf } from '../registry/items.js';
+import { addRule } from '../registry/program.js';
+/**
+ * Declares a rule, which applies in every world, and returns it: identified by that value, labeled by its name. 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 = (declaration) => {
+    const id = takeIdOfDeclaration(declaration);
+    const name = nameOf(declaration.name, id, "rule");
+    const { components, derive } = declaration;
+    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.`);
+    }
+    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 = { kind: "rule", name, declaration };
+    return addRule(rule, id);
+};
+//# sourceMappingURL=create.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../src/interface/rule/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAIjD;;;;GAIG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAA8B,WAAc,EAA6B,EAAE;IAC7F,MAAM,EAAE,GAAG,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;IAClD,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,WAAW,CAAC;IAC3C,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,UAAU,CAAC,GAAG,IAAI,EAAE,EAAE,GAAG,UAAU,CAAC,GAAG,IAAI,EAAE,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC;QAC9E,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,WAAW;YAAE,MAAM,IAAI,KAAK,CAAC,SAAS,IAAI,WAAW,OAAO,CAAC,GAAG,CAAC,wCAAwC,CAAC,CAAC;IACnI,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,aAAa,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,SAAS,IAAI,cAAc,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;IACzI,CAAC;IACD,MAAM,IAAI,GAAe,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAC7D,OAAO,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAC7B,CAAC,CAAC"}

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

@@ -0,0 +1,7 @@
+import type { Declaration } 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;
+};

package/dist/interface/rule/created.js

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

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

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

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

@@ -0,0 +1,13 @@
+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[];
+    };
+    /** Components present on matching entities, while any rule deriving them matches. */
+    readonly derive: readonly Derived[];
+};

package/dist/interface/rule/declaration.js

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

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

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

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

@@ -0,0 +1 @@
+export * from './create.js';

package/dist/interface/rule/index.js

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

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

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

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

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

package/dist/interface/rule/name.js

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

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

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

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

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

package/dist/interface/rule/rule.js

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+type Method = (...parameters: never[]) => unknown;
+/** Whether an object type has a method of its own, so it isn't data, looked at without recursing. */
+type HasMethod<T> = true extends {
+    [K in keyof T]-?: T[K] extends Method ? true : false;
+}[keyof T] ? true : false;
+/**
+ * Whether a value is a struct: numbers, booleans, entities, fixed-length tuples and structs of those, so its schema has
+ * a fixed size. A struct lives in shared memory, where every thread reads it.
+ */
+export type IsStruct<T> = [
+    T
+] extends [number | boolean] ? true : [
+    T
+] extends [Method] ? false : [
+    T
+] extends [readonly unknown[]] ? (number extends T["length"] ? false : IsStruct<T[number]>) : [
+    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 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;
+/**
+ * Whether a value lives in shared memory, where every thread reads it: a struct or a string. Any other value is an
+ * object, which lives on one logical thread's heap, variable-length arrays included.
+ */
+export type IsShared<T> = IsString<T> extends true ? true : IsStruct<T>;
+export {};

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

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

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

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

package/dist/interface/schema/schema.d.ts

@@ -0,0 +1,151 @@
+import type { Entity } from '../entity/entity.js';
+/** Any value representable in JSON. */
+type JSONValue = string | number | boolean | null | readonly JSONValue[] | {
+    readonly [key: string]: JSONValue;
+};
+/**
+ * How a linear value is laid out in memory, and a promise that it's GPU compatible: registration throws if it isn't.
+ * - `storage`: WGSL storage-buffer layout, so a shader's matching `array<T>` reads the column directly.
+ * - `vertex`: tightly packed, as WebGPU vertex buffers expect.
+ * Without it, the value is packed tightly for the CPU and may use any linear type.
+ */
+type GpuLayout = 'storage' | 'vertex';
+interface ObjectSchema<K extends string = string> {
+    readonly type: 'object';
+    readonly properties: {
+        readonly [P in K]: Schema;
+    };
+    readonly required?: readonly K[];
+    readonly layout?: GpuLayout;
+}
+interface StringSchema {
+    readonly type: 'string';
+    readonly minLength?: number;
+    readonly maxLength?: number;
+}
+interface ArraySchema<T extends Schema> {
+    readonly type: 'array';
+    readonly items: T;
+    readonly layout?: GpuLayout;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+}
+interface NumberSchema {
+    readonly type: 'number';
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly precision?: 1 | 2;
+}
+/** 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';
+}
+interface IntegerSchema {
+    readonly type: 'integer';
+    readonly format?: never;
+    readonly minimum?: number;
+    readonly maximum?: number;
+}
+interface BooleanSchema {
+    readonly type: 'boolean';
+}
+interface NullSchema {
+    readonly type: 'null';
+}
+/** 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;
+}
+/** A `ReadonlyMap` from `keys`' values to `values`' values. JSON has no map, so `'map'` isn't a JSON Schema type. */
+interface MapSchema<K extends Schema, V extends Schema> {
+    readonly type: 'map';
+    readonly keys: K;
+    readonly values: V;
+}
+/** Matches exactly one JSON value of any shape. */
+interface ConstSchema {
+    /** The value alone fully describes the schema; combining it with `type` is redundant and disallowed. */
+    readonly type?: never;
+    readonly const: JSONValue;
+}
+interface AndSchema {
+    readonly allOf: readonly Schema[];
+}
+interface OrSchema {
+    readonly anyOf: readonly Schema[];
+}
+/**
+ * A JSON Schema of the forms the ECS reads, and two forms JSON lacks: `{ type: 'set', items }` and
+ * `{ type: 'map', keys, values }`.
+ */
+export type Schema = EntitySchema | ObjectSchema | StringSchema | ArraySchema<Schema> | NumberSchema | IntegerSchema | BooleanSchema | NullSchema | SetSchema<Schema> | MapSchema<Schema, Schema> | ConstSchema | AndSchema | OrSchema;
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+export declare namespace Schema {
+    /** Object properties are all required unless `required` is present, then only those listed are. */
+    type ObjectToType<T extends ObjectSchema> = T extends {
+        required: readonly (infer R)[];
+    } ? Flat<{
+        readonly [P in Extract<R, keyof T['properties']>]: Schema.ToType<T['properties'][P]>;
+    } & {
+        readonly [P in Exclude<keyof T['properties'], R>]?: Schema.ToType<T['properties'][P]>;
+    }> : {
+        readonly [P in keyof T['properties']]: Schema.ToType<T['properties'][P]>;
+    };
+    /**
+     * One object type with the properties of an intersection, each as optional and read-only as it was. It's a
+     * conditional, so the result is an anonymous object type, which declarations emitted elsewhere can name.
+     */
+    type Flat<T> = T extends unknown ? {
+        [P in keyof T]: T[P];
+    } : never;
+    /** An array whose `minItems` and `maxItems` are one literal length is a tuple of that length. */
+    type ArrayToType<T, E> = T extends {
+        readonly minItems: infer N extends number;
+        readonly maxItems: infer M extends number;
+    } ? number extends N ? readonly E[] : [N] extends [M] ? [M] extends [N] ? Tuple<N, E> : readonly E[] : readonly E[] : readonly E[];
+    type Tuple<N extends number, E, R extends readonly unknown[] = readonly []> = R["length"] extends N ? R : Tuple<N, E, readonly [...R, E]>;
+    /**
+     * A literal `const` narrows the type, a fixed-length array is a tuple, and a set or map is a `ReadonlySet` or
+     * `ReadonlyMap`; otherwise the structural type is used.
+     */
+    export type ToType<T extends Schema> = T extends AndSchema ? UnionToIntersection<Schema.ToType<T['allOf'][number]>> : T extends OrSchema ? Schema.ToType<T['anyOf'][number]> : T extends {
+        const: infer C;
+    } ? C : T extends EntitySchema ? Entity : T extends ObjectSchema ? ObjectToType<T> : T extends StringSchema ? string : T extends ArraySchema<infer U> ? ArrayToType<T, Schema.ToType<U>> : T extends SetSchema<infer U> ? ReadonlySet<Schema.ToType<U>> : T extends MapSchema<infer K, infer V> ? ReadonlyMap<Schema.ToType<K>, Schema.ToType<V>> : T extends NumberSchema ? number : T extends IntegerSchema ? number : T extends BooleanSchema ? boolean : T extends NullSchema ? null : never;
+    /** The schemas whose `ToType` is `T`; constrains a schema to describe a known type. */
+    export type ForType<T> = Schema & ([
+        T
+    ] extends [boolean] ? ForNonUnion<T> : IsUnion<T> extends true ? (OrSchema & {
+        anyOf: readonly ForTypeEach<T>[];
+    }) | ([T] extends [string] ? StringSchema : never) : ForNonUnion<T>);
+    type IsUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : never;
+    type ForTypeEach<T> = T extends unknown ? ForType<T> : never;
+    type ForNonUnion<T> = [
+        T
+    ] extends [null] ? NullSchema : [
+        T
+    ] extends [true] ? ConstSchema & {
+        const: T;
+    } : [
+        T
+    ] extends [false] ? ConstSchema & {
+        const: T;
+    } : [
+        T
+    ] extends [boolean] ? BooleanSchema : [
+        T
+    ] extends [Entity] ? EntitySchema : [
+        T
+    ] extends [string] ? (string extends T ? StringSchema : ConstSchema & {
+        const: T;
+    }) : [
+        T
+    ] extends [number] ? (NumberSchema | IntegerSchema) : T extends readonly (infer U)[] ? ArraySchema<ForType<U> & Schema> : T extends ReadonlyMap<infer K, infer V> ? MapSchema<ForType<K> & Schema, ForType<V> & Schema> : T extends ReadonlySet<infer U> ? SetSchema<ForType<U> & Schema> : T extends object ? ObjectSchema<Extract<keyof T, string>> & {
+        properties: {
+            [P in keyof T]-?: ForType<Exclude<T[P], undefined>>;
+        };
+    } : never;
+    export {};
+}
+export {};

package/dist/interface/schema/schema.js

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

package/dist/interface/schema/schema.js.map

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

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

@@ -0,0 +1,71 @@
+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';
+/**
+ * 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.
+ */
+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 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[];
+};
+/**
+ * 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.
+ */
+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[];
+};
+/**
+ * A system's lookup. An index lookup's `changed: true` makes the index a change filter, as a resource in `changed` is:
+ * every row passes when an entity entered or left the index, or moved to another key or position in it, since the
+ * system last ran. A system whose only change filters these are runs only then, skipped before its body otherwise, as
+ * 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;
+};
+/**
+ * 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.
+ */
+export type Up = {
+    readonly through: Component.With<"reference">;
+    readonly read?: readonly Component.Key[];
+};
+/**
+ * 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.
+ */
+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. */
+    readonly is?: readonly Condition[];
+    /** Runs only while each of these is `null` or `false`. Otherwise it's skipped, successfully. */
+    readonly not?: readonly Condition[];
+};

package/dist/interface/system/access.js

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

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

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

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

@@ -0,0 +1,56 @@
+import type { Component } from '../component/component.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 { 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. */
+export type Row<D extends Declaration> = {
+    readonly entity: Entity;
+} & Values<Listed<Property<D, "components">, "read">, Listed<Property<D, "components">, "write">, Component.Key, ComponentValues>;
+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.
+ */
+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>;
+    };
+}) & ([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">>;
+} : {}) & (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;
+} : {}) & (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> = 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;
+export {};

package/dist/interface/system/body.js

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

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

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

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

@@ -0,0 +1,14 @@
+import type { Composite } from './composite.js';
+import type { Leaf } from './leaf.js';
+/**
+ * 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
+ * reductions, conditions, `up` or placement can't hold.
+ */
+export declare const checkLeaf: (leaf: Leaf) => void;
+/**
+ * Throws for a member no System constructor returned, members ordered in a cycle, two that conflict with no order
+ * between them, or an input field two members declare with different schemas.
+ */
+export declare const checkComposite: (composite: Composite) => void;