@adobe/ecs 0.2.0 → 0.2.1

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

@@ -5,10 +5,10 @@ import type { Resource } from '../resource/resource.js';
 import type { Comparison } from '../world/filter.js';
 import type { Listed, Property } from './property.js';
 export type ComponentValues = {
-    readonly [K in Component.Key]: Component.Value<K>;
+    readonly [K in Component.Key]: Component<K>;
 };
 export type ResourceValues = {
-    readonly [K in Resource.Key]: Resource.Value<K>;
+    readonly [K in Resource.Key]: Resource<K>;
 };
 /** `Read` values are read-only, `Write` values writable. */
 export type Values<Read, Write, Keys extends PropertyKey, Types> = {
@@ -24,7 +24,7 @@ export type KeyOf<D> = D extends {
 export type HeldBy<D> = KeyOf<D>[number] | Listed<Property<D, "components">, "with">;
 /** The key's values, in key order. */
 type KeyValues<K extends readonly Component.Key[]> = {
-    readonly [I in keyof K]: Component.Value<K[I] & Component.Key>;
+    readonly [I in keyof K]: Component<K[I] & Component.Key>;
 };
 /** A prefix of the key, possibly empty, whose last part may be a comparison. */
 type Prefix<V extends readonly unknown[]> = V extends readonly [infer First, ...infer Rest] ? readonly [] | readonly [First | Comparison<First>] | readonly [First, ...Prefix<Rest>] : readonly [];
@@ -32,7 +32,7 @@ type Prefix<V extends readonly unknown[]> = V extends readonly [infer First, ...
 type IndexRow<D> = {
     readonly entity: Entity;
 } & {
-    readonly [K in HeldBy<D> & Component.Key]: Component.Value<K>;
+    readonly [K in HeldBy<D> & Component.Key]: Component<K>;
 };
 /**
  * The rows a lookup found, in the index's order: by entity for a hash index, by key and then entity for a sorted one.
@@ -65,7 +65,7 @@ type IndexLookup<D> = D extends {
 type EntityRow<L> = {
     readonly [K in (Listed<L, "with"> & Component.Key) | (Exclude<Listed<L, "optional">, Listed<L, "with">> & Component.Key) | (L extends {
         readonly changed: readonly Component.Key[];
-    } ? "changed" : never)]: K extends Component.Key ? K extends Listed<L, "with"> ? Component.Value<K> : Component.Value<K> | undefined : boolean;
+    } ? "changed" : never)]: K extends Component.Key ? K extends Listed<L, "with"> ? Component<K> : Component<K> | undefined : boolean;
 };
 export type LookupFunction<L> = L extends {
     readonly index: Index<infer D>;

package/dist/interface/trait/types.d.ts

@@ -7,7 +7,7 @@ import type { Reduction } from '../resource/reduction.js';
 import type { IsComparable, IsString, IsStruct } from '../schema/is-struct.js';
 import type { Thread } from '../thread/thread.js';
 /** The value type of the component or resource `N`. */
-type ValueOf<N> = N extends Component.Key ? Component.Value<N> : N extends Resource.Key ? Resource.Value<N> : never;
+type ValueOf<N> = N extends Component.Key ? Component<N> : N extends Resource.Key ? Resource<N> : never;
 /**
  * Whether each component's and resource's value is a struct, `"string"` for a string, computed once so a check is a
  * lookup. Its keys are remapped (`as K`) so a generic key's lookup stays one: resolved as `IsStruct` of a generic value,
@@ -44,12 +44,12 @@ export interface Traits<N extends Component.Key | Resource.Key> {
         readonly derived: true;
     } | {
         readonly shared: true;
-    } ? never : [Component.Value<N>] extends [Entity] ? "owner" | "weak" : never : never;
+    } ? never : [Component<N>] extends [Entity] ? "owner" | "weak" : never : never;
     /**
      * On a resource, the operator systems reduce into it with: each run that a contributor runs in starts it at the
      * operator's identity and leaves it holding the fold of every contribution. Booleans fold bitwise.
      */
-    readonly reduce: N extends Resource.Key ? [Resource.Value<N>] extends [boolean] ? "&" | "|" | "^" : Structs[N] extends true ? Reduction : never : never;
+    readonly reduce: N extends Resource.Key ? [Resource<N>] extends [boolean] ? "&" | "|" | "^" : Structs[N] extends true ? Reduction : never : never;
     /**
      * The logical thread an object lives on, `"world"` without it. Not on a struct or a string, which live in shared
      * memory. A DOM `Node` lives on `"main"`, and says so.
@@ -69,6 +69,6 @@ export interface Traits<N extends Component.Key | Resource.Key> {
         readonly derived: true;
     } | {
         readonly reference: unknown;
-    } ? never : IsComparable<Component.Value<N>> extends true ? true : never : never;
+    } ? never : IsComparable<Component<N>> extends true ? true : never : never;
 }
 export {};

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

@@ -4,15 +4,11 @@ import type { InvalidDeclarations } from './declarations.js';
 import type { World } from './world.js';
 /** Values resources start at in place of their defaults: any but those only the world writes. */
 export type InitialResources = {
-    readonly [K in Exclude<Resource.Key, WorldWritten>]?: Resource.Value<K>;
+    readonly [K in Exclude<Resource.Key, WorldWritten>]?: Resource<K>;
 };
 /**
- * Creates a world on this thread, synchronously, with resources starting at the given values in place of their
- * defaults. This thread is its `"world"` thread for the world's life: it runs the sync points, the ticks and the GPU
- * device, and fills every logical thread no joined thread claims. Keys are the resources' symbols, built-in ones
- * included (`{ [workers]: 0 }`); string keys are never a resource's, so they're ignored. Throws for a symbol that isn't
- * a resource, or is one only the world writes. While a declaration's trait or default doesn't hold, each call fails to
- * compile, once, naming each such key, its members and what's wrong with them.
+ * The type of `World.create`.
+ * @inline
  */
 export type Create = (this: [InvalidDeclarations] extends [never] ? unknown : {
     readonly "declarations don't hold": {

package/dist/interface/world/declarations.d.ts

@@ -30,8 +30,8 @@ type Reported<K, Members extends PropertyKey> = [Members] extends [never] ? neve
  * `World.create` reports these.
  */
 export type InvalidDeclarations = {
-    readonly [K in Component.Key]: Reported<K, Invalid<K, Components[K], Component.Value<K>>>;
+    readonly [K in Component.Key]: Reported<K, Invalid<K, Components[K], Component<K>>>;
 }[Component.Key] | {
-    readonly [K in Resource.Key]: Reported<K, Invalid<K, Resources[K], Resource.Value<K>>>;
+    readonly [K in Resource.Key]: Reported<K, Invalid<K, Resources[K], Resource<K>>>;
 }[Resource.Key];
 export {};

package/dist/interface/world/join.d.ts

@@ -1,16 +1,8 @@
 import type { Thread } from '../thread/thread.js';
 import type { World } from './world.js';
 /**
- * Joins, from another thread, a world that `share` let join through the other end of `port`, claiming the logical
- * `threads` this thread fills: their objects live here, and the systems and finalizers reading them run here. Resolves,
- * once the world accepted the claim, to the same world: its `run` runs systems there, and its `add` and `remove` take
- * observer systems, which run here after the world's sync points. Add them before awaiting anything else, so the
- * world's `share` resolves with them in place. Its `dispose` disconnects this thread. Rejects with an `Error` saying
- * why it didn't join: the world refused the claim, was disposed, or its thread ended first, as the platform reports it:
- * the world's `Worker` failing to start or throwing first, a port closed, as in node, or, in a browser, the world's
- * thread ending once it was shared through a port this thread listened on. A browser world's worker that the page ended
- * before this thread heard from it isn't reported, so the join stays pending. Rejects too where memory can't be shared,
- * as without cross-origin isolation.
+ * The type of `World.join`.
+ * @inline
  */
 export type Join = (port: Parameters<World["share"]>[0], options?: {
     readonly threads?: readonly Exclude<Thread, "world">[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/ecs",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Adobe ECS",
   "license": "MIT",
   "type": "module",

package/src/exports.test.ts

@@ -152,7 +152,7 @@ const customTrait = creating(`
 export const instanced = Symbol();
 export const foo = Symbol();
 declare module "@adobe/ecs" {
-    interface Traits<N> { readonly [instanced]: N extends Component.Key ? ([Component.Value<N>] extends [readonly number[]] ? true : never) : never }
+    interface Traits<N> { readonly [instanced]: N extends Component.Key ? ([Component<N>] extends [readonly number[]] ? true : never) : never }
     interface Components { [foo]: { type: string; [instanced]: true } }
 }`);
 
@@ -182,7 +182,7 @@ const severalTraits = creating(`
 export const instanced = Symbol();
 export const name = Symbol();
 declare module "@adobe/ecs" {
-    interface Traits<N> { readonly [instanced]: N extends Component.Key ? ([Component.Value<N>] extends [readonly number[]] ? true : never) : never }
+    interface Traits<N> { readonly [instanced]: N extends Component.Key ? ([Component<N>] extends [readonly number[]] ? true : never) : never }
     interface Components { [name]: { type: string; [instanced]: true; thread: "main" } }
 }`);
 

package/src/guide/03-systems.out

@@ -1,5 +1,5 @@
 at [ 0, 1, 5 ]
 moving [ 'at 2', 'at 2', 'still' ]
 frames 1
-Error: System "fail" (@adobe/ecs@0.2.0/src/guide/03-systems.ts#fail) failed: broken
+Error: System "fail" (@adobe/ecs@0.2.1/src/guide/03-systems.ts#fail) failed: broken
 frames 2

package/src/guide/11-traits.type-test.ts

@@ -5,7 +5,7 @@ import { Component } from "../index.js";
 export const instanced = Symbol();
 declare module "@adobe/ecs" {
     interface Traits<N> {
-        readonly [instanced]: N extends Component.Key ? ([Component.Value<N>] extends [readonly number[]] ? true : never) : never;
+        readonly [instanced]: N extends Component.Key ? ([Component<N>] extends [readonly number[]] ? true : never) : never;
     }
 }
 

package/src/guide/18-identity.out

@@ -1 +1 @@
-Error: System "explode" (@adobe/ecs@0.2.0/src/guide/18-identity.ts#explode) failed: boom
+Error: System "explode" (@adobe/ecs@0.2.1/src/guide/18-identity.ts#explode) failed: boom

package/src/implementation/world/create.ts

@@ -46,7 +46,7 @@ import { createState, defaultOf, idOf, reside, startTicking, type Key } from './
 import { indexOf } from './entities.js';
 import { touchedHeld } from './up.js';
 import { isHeld } from './transfers.js';
-import type { ReadonlyValue as ReadonlyResourceValue } from '../../interface/resource/value.js';
+import type { ReadonlyType as ReadonlyResourceType } from '../../interface/resource/value.js';
 import { labelOf, whyUnregistered } from '../../interface/registry/index.js';
 
 type Queue = <T>(task: () => T | Promise<T>) => Promise<T>;
@@ -425,12 +425,12 @@ export const createWorld = (resources: InitialResources = {}, options: WorldOpti
     const deviceId = idOf(state, gpuDevice);
     const deviceDefault = defaultOf(gpuDevice);
     /** The `gpuDevice` resource's value, read each run, so without allocating. */
-    const readDevice = (): ReadonlyResourceValue<typeof gpuDevice> => {
+    const readDevice = (): ReadonlyResourceType<typeof gpuDevice> => {
         const index = state.resourceEntity < 0 ? -1 : indexOf(state.resourceEntity);
         const storage = index < 0 ? undefined : state.archetypes[state.entities.archetype[index]]?.storageById[deviceId];
         const value = storage !== undefined ? readCell(storage, state.entities.row[index]) : state.initial.has(gpuDevice) ? state.initial.get(gpuDevice) : deviceDefault;
         // The resource's value matches its registered schema, `GPUDevice | null`.
-        return value as ReadonlyResourceValue<typeof gpuDevice>;
+        return value as ReadonlyResourceType<typeof gpuDevice>;
     };
 
     /**

package/src/implementation/world/finalizers.ts

@@ -12,7 +12,7 @@ import { asEntity, indexOf, locate } from './entities.js';
 import { createContext, rowBinder, type Context } from './rows.js';
 import { idOf, type Key, type State } from './state.js';
 import type { Queued } from './synchronize.js';
-import type { Essential, ReadonlyValue } from '../../interface/component/value.js';
+import type { Essential, ReadonlyType } from '../../interface/component/value.js';
 import type { Leaf } from '../../interface/finalizer/created.js';
 import { newestKeyOf, threadOf } from '../../interface/registry/index.js';
 import type { Layout } from '../../interface/registry/layout.js';
@@ -369,8 +369,8 @@ const changesOf = (state: State, runner: FinalizerRunner, queued: readonly Queue
     return {
         groups: [...groups.values()],
         // Stored and commanded values match each component's registered schema, so they have its type.
-        previous: <K extends Essential>(entity: Entity, key: K) => (bornHere(entity) ? null : live(entity, idOf(state, key))) as ReadonlyValue<K> | null,
-        next: <K extends Essential>(entity: Entity, key: K) => next(entity, idOf(state, key)) as ReadonlyValue<K> | null,
+        previous: <K extends Essential>(entity: Entity, key: K) => (bornHere(entity) ? null : live(entity, idOf(state, key))) as ReadonlyType<K> | null,
+        next: <K extends Essential>(entity: Entity, key: K) => next(entity, idOf(state, key)) as ReadonlyType<K> | null,
     };
 };
 

package/src/implementation/world/pool-size.cases.ts

@@ -12,7 +12,9 @@ export const poolSizeCases = (load: () => Promise<typeof Fixture>) => describe("
     });
     it("honors a number, and null again gives the platform's choice", async () => {
         const fixture = await load();
-        expect((await fixture.resized(1, [null])).started).toEqual([1, 1 + fixture.platformCount()]);
+        // The platform's choice starts a pool of its own unless it's the size the pool already is.
+        const platform = fixture.platformCount();
+        expect((await fixture.resized(1, [null])).started).toEqual([1, platform === 1 ? 1 : 1 + platform]);
     });
     it("starts the pool only once a kernel has rows enough for workers", async () => {
         const fixture = await load();

package/src/implementation/world/reads.test-helper.ts

@@ -1,17 +1,17 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Component } from '../../interface/component/component.js';
-import type { ReadonlyValue } from '../../interface/component/value.js';
+import type { ReadonlyType } from '../../interface/component/value.js';
 import type { Entity } from '../../interface/entity/entity.js';
 import type { Resource } from '../../interface/resource/resource.js';
-import type { ReadonlyValue as ReadonlyResourceValue } from '../../interface/resource/value.js';
+import type { ReadonlyType as ReadonlyResourceType } from '../../interface/resource/value.js';
 import type { World } from '../../interface/world/world.js';
 import { Observe } from '../../observe/index.js';
 
 // Tests' reads: each is the first value of an observer factory of `src/observe`.
 
 /** One component of an entity, or `null` if it's dead or lacks it. */
-export const read = async <C extends Component.Key>(world: World, entity: Entity, component: C): Promise<ReadonlyValue<C> | null> => {
-    const values: { readonly [K in C]: ReadonlyValue<K> } | null = await Observe.toPromise(Observe.entity(world, entity, { required: [component] }));
+export const read = async <C extends Component.Key>(world: World, entity: Entity, component: C): Promise<ReadonlyType<C> | null> => {
+    const values: { readonly [K in C]: ReadonlyType<K> } | null = await Observe.toPromise(Observe.entity(world, entity, { required: [component] }));
     return values === null ? null : values[component];
 };
 
@@ -19,12 +19,12 @@ export const read = async <C extends Component.Key>(world: World, entity: Entity
 export const readEntity = <const C extends readonly Component.Key[]>(world: World, entity: Entity, components: C) =>
     Observe.toPromise(Observe.entity(world, entity, { required: components }));
 
-export const readResource = <R extends Resource.Key>(world: World, name: R): Promise<ReadonlyResourceValue<R>> => Observe.toPromise(Observe.resource(world, name));
+export const readResource = <R extends Resource.Key>(world: World, name: R): Promise<ReadonlyResourceType<R>> => Observe.toPromise(Observe.resource(world, name));
 
 export const select = <const R extends readonly Component.Key[] = []>(world: World, query: Observe.Query<R>): Promise<readonly Entity[]> => Observe.toPromise(Observe.select(world, query));
 
 export const count = <const R extends readonly Component.Key[] = []>(world: World, query: Omit<Observe.Query<R>, "order">): Promise<number> => Observe.toPromise(Observe.count(world, query));
 
 /** One component of each of these entities, `null` for one that's dead or lacks it. */
-export const readEach = <C extends Component.Key>(world: World, entities: readonly Entity[], component: C): Promise<(ReadonlyValue<C> | null)[]> =>
+export const readEach = <C extends Component.Key>(world: World, entities: readonly Entity[], component: C): Promise<(ReadonlyType<C> | null)[]> =>
     Promise.all(entities.map(entity => read(world, entity, component)));

package/src/index.ts

@@ -18,4 +18,27 @@ export type World = Created;
  * values in place of their defaults; and how another thread joins one that shared itself with it,
  * `World.join(port, { threads })`.
  */
-export const World: { readonly create: Create; readonly join: Join } = { create, join };
+export const World: {
+    /**
+     * Creates a world on this thread, synchronously, with resources starting at the given values in place of their
+     * defaults. This thread is its `"world"` thread for the world's life: it runs the sync points, the ticks and the GPU
+     * device, and fills every logical thread no joined thread claims. Keys are the resources' symbols, built-in ones
+     * included (`{ [workers]: 0 }`); string keys are never a resource's, so they're ignored. Throws for a symbol that isn't
+     * a resource, or is one only the world writes. While a declaration's trait or default doesn't hold, each call fails to
+     * compile, once, naming each such key, its members and what's wrong with them.
+     */
+    readonly create: Create;
+    /**
+     * Joins, from another thread, a world that `share` let join through the other end of `port`, claiming the logical
+     * `threads` this thread fills: their objects live here, and the systems and finalizers reading them run here. Resolves,
+     * once the world accepted the claim, to the same world: its `run` runs systems there, and its `add` and `remove` take
+     * observer systems, which run here after the world's sync points. Add them before awaiting anything else, so the
+     * world's `share` resolves with them in place. Its `dispose` disconnects this thread. Rejects with an `Error` saying
+     * why it didn't join: the world refused the claim, was disposed, or its thread ended first, as the platform reports it:
+     * the world's `Worker` failing to start or throwing first, a port closed, as in node, or, in a browser, the world's
+     * thread ending once it was shared through a port this thread listened on. A browser world's worker that the page ended
+     * before this thread heard from it isn't reported, so the join stays pending. Rejects too where memory can't be shared,
+     * as without cross-origin isolation.
+     */
+    readonly join: Join;
+} = { create, join };

package/src/interface/component/component.ts

@@ -1,5 +1,11 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Key } from './key.js';
+import type { Type } from './value.js';
 
-export type Component = never;
+/**
+ * The type of component `K`'s value, as its record in `Components` declares it: `Component<typeof position>`. The
+ * namespace's `Key` and `With` name components' keys.
+ */
+export type Component<K extends Key> = Type<K>;
 
 export * as Component from './index.js';

package/src/interface/component/index.ts

@@ -1,3 +1,3 @@
 // © 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/value.ts

@@ -4,16 +4,16 @@ 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];
@@ -35,7 +35,7 @@ export type Shared = With<"shared">;
 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,6 +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/finalizer/body.ts

@@ -6,7 +6,7 @@ import type { Listed, Property } from '../system/property.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';
 
 /**
@@ -14,8 +14,8 @@ import type { Elsewhere, ThreadsOf } from '../system/threads.js';
  * 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">, "with"> & Component.Key]: Component.Value<K> }
-    & { readonly [K in Exclude<Listed<Property<D, "components">, "optional">, Listed<Property<D, "components">, "with">> & Component.Key]: Component.Value<K> | undefined };
+    { 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 };
 
 /**
  * Every resource, its lookups when declared, and the commands it issues for the next sync point: none on another
@@ -46,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/index.type-test.ts

@@ -36,7 +36,7 @@ export const added = world.add(read);
 // Only types a consumer declares with are named; the rest are inferred where wanted.
 // @ts-expect-error a thread's name is keyof Threads
 export type NoThread = Ecs.Thread;
-// @ts-expect-error the cadence's value is Resource.Value<typeof cadence>
+// @ts-expect-error the cadence's value is Resource<typeof cadence>
 export type NoCadence = Ecs.Cadence;
 // @ts-expect-error a rule is the value Rule.create returns: ReturnType<typeof Rule.create>
 export const noRule: Rule = Rule.create({ components: { with: [position] }, derive: [slot] });

package/src/interface/resource/condition.ts

@@ -1,9 +1,9 @@
 // © 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';
 
 /** The resources a system can run on the condition of: their type allows `null` or `false`. */
-export type Condition = { [K in Key]: null extends Value<K> ? K : false extends Value<K> ? K : never }[Key];
+export type Condition = { [K in Key]: null extends Type<K> ? K : false extends Type<K> ? K : never }[Key];
 
 /** A condition's value while `is` holds: neither `null` nor `false`. */
-export type Holding<K extends Key> = Exclude<Value<K>, null | false>;
+export type Holding<K extends Key> = Exclude<Type<K>, null | false>;

package/src/interface/resource/index.ts

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

package/src/interface/resource/resource.ts

@@ -1,5 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Key } from './key.js';
+import type { Type } from './value.js';
 
-export type Resource = never;
+/** The type of resource `K`'s value, as its record in `Resources` declares it: `Resource<typeof clock>`. */
+export type Resource<K extends Key> = Type<K>;
 
 export * as Resource from './index.js';

package/src/interface/resource/value.ts

@@ -3,19 +3,19 @@ import type { ThreadOf } from '../thread/of.js';
 import type { Key } from "./key.js";
 import type { Resources } from "./types.js";
 
-/** Every resource's value type, computed once so `Value` is a lookup. */
-type ValueTypes = { readonly [K in Key]: Resources[K] extends { readonly type: infer T } ? T : never };
+/** Every resource's value type, computed once so `Type` is a lookup. */
+type Types = { readonly [K in Key]: Resources[K] extends { readonly type: infer T } ? T : never };
 
 /** The value type of resource `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;
 
 /** Resource `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>>;
 
 /** Every resource's thread, computed once so `ThreadOf` is a lookup. */
-type Threads = { readonly [K in Key]: ThreadOf<Resources[K], Value<K>> };
+type Threads = { readonly [K in Key]: ThreadOf<Resources[K], Type<K>> };
 
 /** The thread resource `K` lives on, or `never` for a struct, which lives in shared memory. */
 export type ThreadOfResource<K extends Key> = Threads[K];

package/src/interface/resources/cadence.ts

@@ -1,7 +1,7 @@
 // © 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 };
 
 /**

package/src/interface/system/access.ts

@@ -26,7 +26,7 @@ export type ComponentAccess = {
      * 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.Value<K> | ((value: Component.Value<K>, context: { readonly resources: ReadResources }) => boolean) };
+    readonly where?: { readonly [K in Shared]?: Component<K> | ((value: Component<K>, context: { readonly resources: ReadResources }) => boolean) };
 };
 
 /**

package/src/interface/system/body.ts

@@ -23,7 +23,7 @@ type Reading<D> = D extends { readonly observer: true } | { readonly shader: obj
 export type Optional<D> = Exclude<Listed<Property<D, "components">, "optional">, Members<D>>;
 
 /** Each optional component's value or `undefined`, as `ComponentValues` gives members'. */
-type OptionalValues = { readonly [K in Component.Key]: Component.Value<K> | undefined };
+type OptionalValues = { readonly [K in Component.Key]: Component<K> | undefined };
 
 /**
  * Its members' values, writable but for references and shared components, and in a system that only reads; its
@@ -45,7 +45,7 @@ export type ReadResources = Values<Resource.Key, never, Resource.Key, ResourceVa
 export type WriteResources = Values<Resource.Key, Writes, Resource.Key, ResourceValues>;
 
 /** Each reduced resource, as a function contributing a value to the run's fold. */
-type Reductions = { readonly [K in Reduced]: (value: Resource.Value<K>) => void };
+type Reductions = { readonly [K in Reduced]: (value: Resource<K>) => void };
 
 type Is<D> = Listed<Property<D, "resources">, "is">;
 

package/src/interface/system/commands.ts

@@ -5,13 +5,13 @@ import type { Essential, Shared } from '../component/value.js';
 import type { ValuesOf } from './values-of.js';
 
 /** The value an `add` of one component takes: none for a tag. */
-type ValueArgument<K extends Essential> = Component.Value<K> extends true ? [value?: true] : [value: Component.Value<K>];
+type ValueArgument<K extends Essential> = Component<K> extends true ? [value?: true] : [value: Component<K>];
 
 /** Values of components of `C` a spawner's first call may give, constant for every entity it spawns. */
-type Preset<C extends readonly Essential[]> = { readonly [K in C[number]]?: Component.Value<K> };
+type Preset<C extends readonly Essential[]> = { readonly [K in C[number]]?: Component<K> };
 
 /** The value of each shared component of `C`, which a spawner's first call must give, since they choose the archetype. */
-type SharedPreset<C extends readonly Essential[]> = { readonly [K in C[number] & Shared]: Component.Value<K> };
+type SharedPreset<C extends readonly Essential[]> = { readonly [K in C[number] & Shared]: Component<K> };
 
 /**
  * Whether `C` names a shared component, so a spawner of it takes its constants: a list that isn't a tuple, whose
@@ -27,7 +27,7 @@ type Named<C extends readonly Essential[], P> = { readonly [K in Exclude<keyof P
  * the spawn takes their values first.
  */
 type Spawned<C extends readonly Essential[], P> = RequiresPreset<C> extends true
-    ? [keyof P] extends [never] ? C & { readonly "error: a spawn of a shared component takes its value first, in its constants": { readonly [K in C[number] & Shared]: Component.Value<K> } } : C
+    ? [keyof P] extends [never] ? C & { readonly "error: a spawn of a shared component takes its value first, in its constants": { readonly [K in C[number] & Shared]: Component<K> } } : C
     : C;
 
 /** Each component of `C` the constants `P` gave, whose value a spawn's values give again as a message naming it. */

package/src/interface/system/struct.ts

@@ -4,7 +4,7 @@ import type { Resource } from '../resource/resource.js';
 import type { IsStruct } from '../schema/is-struct.js';
 
 /** Components whose values are structs, which kernels read and write. */
-export type StructComponent = { [K in Component.Key]: IsStruct<Component.Value<K>> extends true ? K : never }[Component.Key];
+export type StructComponent = { [K in Component.Key]: IsStruct<Component<K>> extends true ? K : never }[Component.Key];
 
 /** Resources whose values are structs, which kernels read. */
-export type StructResource = { [K in Resource.Key]: IsStruct<Resource.Value<K>> extends true ? K : never }[Resource.Key];
+export type StructResource = { [K in Resource.Key]: IsStruct<Resource<K>> extends true ? K : never }[Resource.Key];

package/src/interface/system/values-of.ts

@@ -2,7 +2,7 @@
 import type { Component } from '../component/component.js';
 
 /** Components a spawn or add may leave out: a tag, whose value is `true`, and one whose type allows `null`, its start. */
-type Omissible<K extends Component.Key> = Component.Value<K> extends true ? K : null extends Component.Value<K> ? K : never;
+type Omissible<K extends Component.Key> = Component<K> extends true ? K : null extends Component<K> ? K : never;
 
 /**
  * The values a spawn or add of the components `C` takes, keyed by component and exact against `C`, but those `Given`
@@ -12,6 +12,6 @@ type Omissible<K extends Component.Key> = Component.Value<K> extends true ? K :
  */
 export type ValuesOf<C extends readonly Component.Key[], Given extends PropertyKey = never> = number extends C["length"]
     // A list whose components aren't known until it runs, so any of them may be given.
-    ? { readonly [K in Exclude<C[number], Given>]?: Component.Value<K> }
-    : { readonly [K in Exclude<C[number], Given> as K extends Omissible<K> ? never : K]: Component.Value<K> }
-        & { readonly [K in Exclude<C[number], Given> as K extends Omissible<K> ? K : never]?: Component.Value<K> };
+    ? { readonly [K in Exclude<C[number], Given>]?: Component<K> }
+    : { readonly [K in Exclude<C[number], Given> as K extends Omissible<K> ? never : K]: Component<K> }
+        & { readonly [K in Exclude<C[number], Given> as K extends Omissible<K> ? K : never]?: Component<K> };

package/src/interface/system/values.ts

@@ -6,8 +6,8 @@ import type { Resource } from '../resource/resource.js';
 import type { Comparison } from '../world/filter.js';
 import type { Listed, Property } from './property.js';
 
-export type ComponentValues = { readonly [K in Component.Key]: Component.Value<K> };
-export type ResourceValues = { readonly [K in Resource.Key]: Resource.Value<K> };
+export type ComponentValues = { readonly [K in Component.Key]: Component<K> };
+export type ResourceValues = { readonly [K in Resource.Key]: Resource<K> };
 
 /** `Read` values are read-only, `Write` values writable. */
 export type Values<Read, Write, Keys extends PropertyKey, Types> =
@@ -21,7 +21,7 @@ export type KeyOf<D> = D extends { readonly key: infer K extends readonly Compon
 export type HeldBy<D> = KeyOf<D>[number] | Listed<Property<D, "components">, "with">;
 
 /** The key's values, in key order. */
-type KeyValues<K extends readonly Component.Key[]> = { readonly [I in keyof K]: Component.Value<K[I] & Component.Key> };
+type KeyValues<K extends readonly Component.Key[]> = { readonly [I in keyof K]: Component<K[I] & Component.Key> };
 
 /** A prefix of the key, possibly empty, whose last part may be a comparison. */
 type Prefix<V extends readonly unknown[]> = V extends readonly [infer First, ...infer Rest]
@@ -29,7 +29,7 @@ type Prefix<V extends readonly unknown[]> = V extends readonly [infer First, ...
     : readonly [];
 
 /** A row an index lookup gives: its entity and the values of what every entity the index holds has, read-only. */
-type IndexRow<D> = { readonly entity: Entity } & { readonly [K in HeldBy<D> & Component.Key]: Component.Value<K> };
+type IndexRow<D> = { readonly entity: Entity } & { readonly [K in HeldBy<D> & Component.Key]: Component<K> };
 
 /**
  * The rows a lookup found, in the index's order: by entity for a hash index, by key and then entity for a sorted one.
@@ -65,7 +65,7 @@ type IndexLookup<D> =
 type EntityRow<L> = {
     readonly [K in (Listed<L, "with"> & Component.Key) | (Exclude<Listed<L, "optional">, Listed<L, "with">> & Component.Key) | (L extends { readonly changed: readonly Component.Key[] } ? "changed" : never)]:
         // Its `optional` components are their values where the entity has them, `undefined` where it doesn't.
-        K extends Component.Key ? K extends Listed<L, "with"> ? Component.Value<K> : Component.Value<K> | undefined : boolean
+        K extends Component.Key ? K extends Listed<L, "with"> ? Component<K> : Component<K> | undefined : boolean
 };
 
 export type LookupFunction<L> = L extends { readonly index: Index<infer D> }

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

@@ -55,7 +55,7 @@ declare module '@adobe/ecs' {
     }
 }
 
-check<Equal<Component.Value<typeof path>, readonly number[]>>();
+check<Equal<Component<typeof path>, readonly number[]>>();
 check<Equal<ThreadOf<{ readonly thread: "main" }, string>, never>>();
 check<Equal<ThreadOf<{ readonly thread: "main" }, "edit" | "view">, never>>();
 check<Equal<ThreadOf<{ readonly thread: "main" }, readonly string[]>, "main">>();