@adobe/ecs 0.1.0 → 0.2.0

package/src/implementation/world/kernel.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { WgslType } from '../../interface/math/intrinsic.js';
 import type { Entity } from '../../interface/entity/entity.js';
 import type { Reduction } from '../../interface/resource/reduction.js';
@@ -19,13 +20,22 @@ export type Column =
     /** Float64Array of the component's changed ticks, stamped with `tick` on each write. */
     | { readonly kind: "changed"; readonly component: Key }
     /**
-     * Float64Array of the component's newest changed tick per chunk of `chunkRows` rows, so change filters can skip
-     * unchanged chunks. Every `changed` column is followed by one, and each stamp sets both: `chunks[row >> chunkShift] = tick`.
+     * Float64Array of the component's newest changed tick per chunk of `2 ** chunkShift` rows, so change filters can
+     * skip unchanged chunks. Every `changed` column is followed by one, then by its `blocks` column.
      */
-    | { readonly kind: "chunks"; readonly component: Key };
+    | { readonly kind: "chunks"; readonly component: Key }
+    /**
+     * Float64Array of the component's newest changed tick per block of `2 ** blockShift` rows, so change filters skip
+     * the unchanged blocks of a chunk that changed. A stamp sets all three: the row's tick, its chunk's and its block's.
+     */
+    | { readonly kind: "blocks"; readonly component: Key }
+    /** Of an optional component: non-empty in an archetype with it and empty in one without, so a kernel tests it once per call. */
+    | { readonly kind: "present"; readonly component: Key };
 
 /** Rows per chunk of change ticks is `2 ** chunkShift`. */
 export const chunkShift = 10;
+/** Rows per block of change ticks is `2 ** blockShift`: a chunk holds `2 ** (chunkShift - blockShift)` blocks. */
+export const blockShift = 6;
 
 /** A leaf of a resource a kernel reduces into, folded with `operator`. */
 export type Reduced = { readonly resource: Key; readonly operator: Reduction; readonly path: Path };
@@ -63,6 +73,8 @@ export type Kernel = (
     upColumns?: readonly (Float64Array | Float32Array | Int32Array | Uint32Array | Uint8Array)[],
     /** Whether the rows have a parent with every component `up` reads. */
     found?: boolean,
+    /** The call's archetype's values of `KernelDescription.shared`, in its order. */
+    shared?: readonly unknown[],
 ) => void;
 
 /** How kernels issue commands. `kind` is 1 for despawn, 2 for add, 3 for remove; `key` indexes the kernel's `keys`. */
@@ -103,6 +115,8 @@ export namespace Program {
         /** A scalar inside `resources[index]`, or inside `args`. */
         | { readonly kind: "resource"; readonly index: number; readonly path: Path }
         | { readonly kind: "args"; readonly path: Path }
+        /** A scalar inside the call's archetype's value of `KernelDescription.shared[index]`, a parameter of each call. */
+        | { readonly kind: "shared"; readonly index: number; readonly path: Path }
         | { readonly kind: "local"; readonly local: number }
         | { readonly kind: "unary"; readonly operator: "-" | "+" | "!" | "~"; readonly operand: Expression }
         | {
@@ -145,8 +159,11 @@ export namespace Program {
         | { readonly kind: "set"; readonly local: number; readonly value: Expression }
         /** `columns[column][row] = value`, with typed-array conversion. */
         | { readonly kind: "store"; readonly column: number; readonly value: Expression }
-        /** `columns[column][row] = tick` and `columns[chunks][row >> chunkShift] = tick`, for a changed column and its chunk column. */
-        | { readonly kind: "stamp"; readonly column: number; readonly chunks: number }
+        /**
+         * `columns[column][row] = tick`, `columns[chunks][row >> chunkShift] = tick` and
+         * `columns[blocks][row >> blockShift] = tick`, for a changed column and its chunk and block columns.
+         */
+        | { readonly kind: "stamp"; readonly column: number; readonly chunks: number; readonly blocks: number }
         | { readonly kind: "if"; readonly test: Expression; readonly consequent: readonly Statement[]; readonly alternate: readonly Statement[] }
         /** WASM `block`: a branch to it exits it. */
         | { readonly kind: "block"; readonly body: readonly Statement[] }
@@ -209,6 +226,8 @@ export type KernelDescription = {
     readonly columns: readonly Column[];
     readonly shapes: readonly Shape[];
     readonly resources: readonly Key[];
+    /** The shared components it reads, whose values each call takes, of its archetype, as parameters. */
+    readonly shared?: readonly Key[];
     readonly lookups: readonly string[];
     /** Each call site of a lookup through an index. */
     readonly probes?: readonly Probe[];
@@ -232,6 +251,11 @@ export type KernelDescription = {
     readonly reductions: readonly Reduced[];
     /** The leaves of each value contributed whole, by resource. Registration checks they are all of the schema's leaves. */
     readonly reducedShapes: readonly Shape[];
+    /**
+     * Whether its arithmetic may round each step to storage precision, as SIMD lanes do: only for a kernel the
+     * declaration asks for. A body compiled unflagged computes as the body as written does.
+     */
+    readonly storagePrecision?: true;
 };
 
 /** What a kernel module at `KernelDescription.url` exports. */
@@ -240,5 +264,5 @@ export type KernelModule = {
      * Called once per registration. Per column `k`: `booleans[k]` is true when it stores booleans as 0 or 1, so reads convert them;
      * a row's element is at `row * strides[k] + offsets[k]`, in elements of the column's array.
      */
-    readonly create: (booleans: readonly boolean[], strides: readonly number[], offsets: readonly number[], upBooleans?: readonly boolean[], upStrides?: readonly number[], upOffsets?: readonly number[]) => Kernel;
+    readonly create: (booleans: readonly boolean[], strides: readonly number[], offsets: readonly number[], upBooleans?: readonly boolean[], upStrides?: readonly number[], upOffsets?: readonly number[], labels?: readonly string[]) => Kernel;
 };

package/src/implementation/world/kernels-csp.test.ts

@@ -1,25 +1,25 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { System } from "../../interface/system/system.js";
 import { readEach, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
 import { workers } from "../../interface/resources/workers.js";
+import type { F32 } from "../../interface/math/index.js";
 
 const value = Symbol("kernelsCspTest/value");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [value]: { type: number };
+        [value]: { type: F32 };
     }
 }
 
-Component.register(value, { type: { type: "number", precision: 1 } });
 
-const seed = System.create({ name: "kernelsCspTest/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     for (let i = 0; i < 10; i++) commands.spawn([value])({ [value]: i });
 });
 
-const double = System.create({ name: "kernelsCspTest/double", kernel: "cpu", components: { write: [value] } }, row => {
+const double = System.create({ kernel: true, components: { with: [value] } }, row => {
     row[value] = row[value] * 2;
 });
 

package/src/implementation/world/kernels.test.ts

@@ -1,10 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
-import { Resource } from "../../interface/resource/resource.js";
 import { System } from "../../interface/system/system.js";
 import { World } from "../../interface/world/world.js";
 import { definitionOf } from "../../interface/registry/index.js";
-import { attachKernel } from "./attach-kernel.js";
+import { attachKernel, kernelOf } from "./attach-kernel.js";
 import { bindKernel } from "./kernels.js";
 import type { KernelDescription } from "./kernel.js";
 import { createState } from "./state.js";
@@ -20,23 +19,19 @@ declare module "@adobe/ecs" {
         [label]: { type: string | null };
     }
     export interface Resources {
-        [scale]: { type: number };
+        [scale]: { type: number; default: 1 };
     }
 }
 
 const label = Symbol("kernelsTest/label");
-Component.register(value, { type: { type: "number" } });
-Component.register(other, { type: { type: "number" } });
-Component.register(label, { type: { anyOf: [{ type: "string" }, { type: "null" }] } });
-Resource.register(scale, { type: { type: "number", default: 1 } });
 
 /** Reads `value` and `other`, writes nothing, reads no resources. */
-const system = System.create({ name: "kernelsTest/read", kernel: "cpu", components: { read: [value, other] } }, row => {
+const system = System.create({ kernel: true, components: { with: [value, other] } }, row => {
     if (row[value] > row[other]) return;
 });
 
-const spawn = System.create({ name: "kernelsTest/spawn" }, ({ commands }) => { commands.spawn([value, other])({ [value]: 3, [other]: 0 }); });
-const double = System.create({ name: "kernelsTest/double", kernel: "cpu", components: { write: [value] } }, row => {
+const spawn = System.create({}, ({ commands }) => { commands.spawn([value, other])({ [value]: 3, [other]: 0 }); });
+const double = System.create({ kernel: true, components: { with: [value] } }, row => {
     row[value] = row[value] * 2;
 });
 
@@ -66,13 +61,22 @@ describe("bindKernel", () => {
 
 describe("attachKernel", () => {
     it("rejects at registration a spawn site naming a component twice", () => {
-        expect(() => attachKernel(system, describing({ keys: [value, other], spawns: [[1, 0, 1]] }))).toThrow('Kernel "kernelsTest/read": spawns a list naming "kernelsTest/other" twice.');
+        expect(() => attachKernel(system, describing({ keys: [value, other], spawns: [[1, 0, 1]] }))).toThrow('spawns a list naming "kernelsTest/other" twice.');
     });
     it("rejects at registration a tuple or struct given to a component without a linear layout", () => {
-        expect(() => attachKernel(system, describing({ keys: [value, label], structuredValues: [1] }))).toThrow('Kernel "kernelsTest/read": gives "kernelsTest/label" a tuple or struct, which only a component stored in linear memory takes.');
+        expect(() => attachKernel(system, describing({ keys: [value, label], structuredValues: [1] }))).toThrow('gives "kernelsTest/label" a tuple or struct, which only a component stored in linear memory takes.');
         expect(() => attachKernel(system, describing({ keys: [value, label], structuredValues: [0] }))).not.toThrow();
     });
+    it("attaches nothing, and throws nothing, for a kernel the build tried that doesn't match", () => {
+        const tried = System.create({ components: { with: [value, other] } }, row => {
+            if (row[value] > row[other]) return;
+        });
+        expect(attachKernel(tried, describing({ keys: [value, label], structuredValues: [1] }), true)).toBe(tried);
+        expect(kernelOf(tried)).toBeUndefined();
+        expect(attachKernel(tried, describing({}), true)).toBe(tried);
+        expect(kernelOf(tried)).toBeDefined();
+    });
     it("rejects at registration a spawn site naming a component outside its keys", () => {
-        expect(() => attachKernel(system, describing({ keys: [value], spawns: [[0, 1]] }))).toThrow('Kernel "kernelsTest/read": spawns a list naming component 1 of its 1 keys.');
+        expect(() => attachKernel(system, describing({ keys: [value], spawns: [[0, 1]] }))).toThrow('spawns a list naming component 1 of its 1 keys.');
     });
 });

package/src/implementation/world/kernels.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Leaf } from '../../interface/system/leaf.js';
 import type { Archetype } from './archetype.js';
 import type { Kernel, KernelDescription, KernelModule } from './kernel.js';
@@ -8,8 +9,10 @@ import type { Since } from './index-lookups.js';
 import { commandIdOf, idOf, type Key, type State } from './state.js';
 import { generateWasm, instantiateWasm, type Type, type WasmColumn, type WasmKernel, type WasmLookup, type WasmRun, type WasmScalar } from './wasm.js';
 import { createDirectory, lookupParameters, type Directory } from './directories.js';
-import { generateWgsl, type WgslKernel } from './wgsl.js';
-import { labelOf, labelOfItem } from '../../interface/registry/index.js';
+import { generateWgsl, type ScalarKind, type WgslKernel } from './wgsl.js';
+import { declarationOf } from '../../interface/registry/index.js';
+import { labelOf } from '../../interface/registry/index.js';
+import { absentColumn, emptyViews } from './arrays.js';
 import type { WorldIndex } from './indexes.js';
 import { kernelIndexesOf, refreshSource, writeIndexParameters, type KernelIndex } from './kernel-indexes.js';
 import { createIndexReader, createIndexSource, type IndexReaderSetup } from './index-readers.js';
@@ -39,6 +42,8 @@ export type BoundKernel = {
         /** By lookup through an index: its lookup, how its JS reader reads it, and how many components it watches. */
         readonly indexes: readonly { readonly lookup: number; readonly reader: IndexReaderSetup; readonly watched: number }[];
         readonly keys: readonly number[];
+        readonly labels: readonly string[];
+        readonly optional: readonly number[];
         readonly starts: readonly unknown[];
         /** The component ids of each list the kernel spawns, in the order its spawner takes values. */
         readonly spawns: readonly (readonly number[])[];
@@ -67,12 +72,21 @@ export type BoundKernel = {
     wasm: WasmKernel | null;
     /** The compiled module and the main thread's instance, once loaded. */
     readonly compiled: () => { readonly module: WebAssembly.Module; readonly run: WasmRun } | null;
+    /** Whether an archetype has every optional component, the only archetypes its WASM runs: JS runs the rest. */
+    readonly allPresent: (archetype: Archetype) => boolean;
     /** For a WASM kernel with lookups: the entity table and directories, passed ahead of the scalars. */
     readonly lookupParameters: () => readonly number[];
     /** The kernel as a compute shader for the components observed at the last load, or why it can't run on the GPU. */
     readonly gpu: () => WgslKernel | string;
+    /** An archetype's values of the shared components it reads, which each call over it takes: read-only, kept per archetype. */
+    readonly sharedOf: (archetype: Archetype) => readonly unknown[];
+    /** How a GPU dispatch's record holds a scalar parameter: a shared value's leaf keeps its type. */
+    readonly scalarKind: (scalar: WasmScalar) => ScalarKind;
 };
 
+/** A kernel reading no shared components takes no values of them. */
+const noShared: readonly unknown[] = [];
+
 /** Whether a scalar leaf at `path` is a boolean, a number, or not a scalar leaf. */
 const leafType = (layout: Layout, path: readonly (number | string)[]): Type | null => {
     if (layout.kind !== "linear") return null;
@@ -86,7 +100,7 @@ const leafType = (layout: Layout, path: readonly (number | string)[]): Type | nu
  */
 export const bindKernel = (state: State, leaf: Leaf, description: KernelDescription, byName: ReadonlyMap<string, WorldIndex> = new Map(), since: Since = { value: 0 }): BoundKernel => {
     const { lookup, components: query } = leaf.declaration;
-    const fail = (message: string): never => { throw new Error(`Kernel "${labelOfItem(leaf)}": ${message}`); };
+    const fail = (message: string): never => { throw new Error(`Kernel "${leaf.name}": ${message}`); };
     const booleans: boolean[] = [];
     // Per column, in elements of its view: entity and tick columns are dense.
     const strides: number[] = [];
@@ -104,11 +118,12 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
             return column;
         }
         const id = idOf(state, column.component);
-        if (column.kind === "changed" || column.kind === "chunks") {
+        if (column.kind === "changed" || column.kind === "chunks" || column.kind === "blocks" || column.kind === "present") {
             dense();
             return { kind: column.kind, id, leaf: 0 };
         }
         const layout = state.layouts[id];
+        if (state.shared[id] !== undefined) return fail(`"${labelOf(column.component)}" is shared, so it has no column: build the kernel with Compiler.plugin(), which reads its declaration's shared trait and passes its value to each call.`);
         if (layout.kind !== "linear") return fail(`"${labelOf(column.component)}" isn't stored in linear memory.`);
         const index = layout.leaves.findIndex(leaf => samePath(leaf.path, column.path));
         if (index < 0) return fail(`"${labelOf(column.component)}" has no scalar at [${column.path.join(", ")}]; destructure tuples and structs or index their fields.`);
@@ -142,6 +157,43 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
     };
     const ids = (keys: readonly Key[] | undefined): number[] => (keys ?? []).map(key => idOf(state, key));
     const keys = description.keys.map(key => commandIdOf(state, key));
+    for (const id of keys) if (state.shared[id] !== undefined) fail(`its commands name "${labelOf(state.keys[id])}", a shared component, whose value chooses an archetype, which only a system run as written on the world's thread does.`);
+    /** The shared components it reads, each call taking its archetype's values of them. */
+    const sharedIds = (description.shared ?? []).map(key => {
+        const id = idOf(state, key);
+        return state.shared[id] === undefined ? fail(`reads "${labelOf(key)}" as shared, which it isn't; rebuild.`) : id;
+    });
+    for (const declared of declaredLookups) {
+        for (const key of declared.read ?? []) if (declarationOf(key)?.shared === true) fail(`a lookup reads "${labelOf(key)}", a shared component, which a kernel reads only of its own rows.`);
+    }
+    for (const key of up?.read ?? []) if (declarationOf(key)?.shared === true) fail(`up reads "${labelOf(key)}", a shared component, which a kernel reads only of its own rows.`);
+    /** By archetype, its values as of its generation: reused for others (`reclaim.ts`), it's read again. */
+    const sharedCache = new Map<Archetype, { readonly generation: number; readonly values: readonly unknown[] }>();
+    const sharedOf = (archetype: Archetype): readonly unknown[] => {
+        if (sharedIds.length === 0) return noShared;
+        const { generation } = archetype;
+        let cached = sharedCache.get(archetype);
+        if (cached === undefined || cached.generation !== generation) {
+            const values = sharedIds.map(id => {
+                const layout = archetype.storageById[id]?.layout;
+                return layout?.kind === "constant" ? layout.value : undefined;
+            });
+            cached = { generation, values };
+            sharedCache.set(archetype, cached);
+        }
+        return cached.values;
+    };
+    /** The leaf a shared value's scalar parameter reads, by its schema's layout. */
+    const sharedLeaf = (scalar: Extract<WasmScalar, { readonly source: "shared" }>) => {
+        const key = description.shared?.[scalar.index];
+        const layout = key === undefined ? undefined : layoutOf(declarationOf(key)?.type);
+        return layout?.kind === "linear" ? layout.leaves.find(candidate => samePath(candidate.path, scalar.path)) ?? null : null;
+    };
+    const scalarKind = (scalar: WasmScalar): ScalarKind => {
+        if (scalar.source !== "shared") return "f32";
+        const found = sharedLeaf(scalar);
+        return found === null ? "f32" : found.scalar === "boolean" ? "bool" : found.scalar === "i32" || found.scalar === "u32" || found.scalar === "f64" ? found.scalar : "f32";
+    };
     const spawns = description.spawns.map(list => list.map(k => keys[k]));
     const setup = {
         sources,
@@ -149,11 +201,14 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
         strides,
         offsets,
         lookups: declaredLookups.map((declared): LookupSetup => ({
-            read: ids(declared.read), has: ids("has" in declared ? declared.has : undefined), not: ids("not" in declared ? declared.not : undefined),
+            read: ids(declared.read), has: ids("has" in declared ? declared.has : undefined), optional: ids("optional" in declared ? declared.optional : undefined), not: ids("not" in declared ? declared.not : undefined),
             changed: "index" in declared || declared.changed === undefined ? null : ids(declared.changed),
         })),
         indexes: indexes.flatMap(bound => bound === null ? [] : [{ lookup: bound.lookup, reader: bound.reader, watched: bound.watched.length }]),
         keys,
+        labels: keys.map(id => labelOf(state.keys[id])),
+        // Only those its body uses: one it declares and never touches doesn't keep an archetype lacking it off WASM.
+        optional: ids(leaf.declaration.components?.optional).filter(id => sources.some(source => source.kind !== "entity" && source.id === id)),
         starts: keys.map(id => state.starts[id]),
         spawns,
     };
@@ -176,16 +231,22 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
         }
         return value;
     };
+    const optional = new Set(setup.optional);
     const cache = new Map<Archetype, { version: number; columns: readonly TypedArray[] }>();
     const columnsOf = (archetype: Archetype): readonly TypedArray[] => {
         const cached = cache.get(archetype);
         if (cached !== undefined && cached.version === archetype.version) return cached.columns;
         const columns = sources.map(source => {
             if (source.kind === "entity") return archetype.entities;
+            // An optional component's presence: any column that has rows where the archetype has it, empty where it doesn't.
+            if (source.kind === "present") return archetype.storageOf.has(source.id) ? archetype.entities : emptyViews.f64;
             const storage = archetype.storageOf.get(source.id);
+            // An optional component's columns are empty where the archetype lacks it: reads give undefined.
+            if (storage === undefined && optional.has(source.id)) return absentColumn(state.layouts[source.id], source);
             if (storage === undefined) return fail(`column of "${labelOf(state.keys[source.id])}" isn't in its components.`);
             if (source.kind === "changed") return storage.changed;
             if (source.kind === "chunks") return storage.chunkChanged;
+            if (source.kind === "blocks") return storage.blockChanged;
             const layout = state.layouts[source.id];
             return layout.kind === "linear" ? storage.views[layout.leaves[source.leaf].view] : fail("a field column isn't linear.");
         });
@@ -218,9 +279,10 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
         upCache.set(archetype, { version: archetype.version, columns });
         return columns;
     };
-    const argsLayout = leaf.declaration.input === undefined ? null : layoutOf(leaf.declaration.input);
+    const argsLayout = leaf.input === undefined ? null : layoutOf(leaf.input);
     const scalarType = (scalar: WasmScalar): Type | null => scalar.source === "args"
         ? argsLayout === null ? null : leafType(argsLayout, scalar.path)
+        : scalar.source === "shared" ? (sharedLeaf(scalar) === null ? null : sharedLeaf(scalar)?.scalar === "boolean" ? "boolean" : "number")
         : scalar.index < description.resources.length ? leafType(state.layouts[idOf(state, description.resources[scalar.index])], scalar.path) : null;
     const useWasm = state.wasm && state.memory.shared && description.program !== null;
     // A lookup through an index's directory also holds each archetype's entities, which its rows' `entity` reads.
@@ -237,12 +299,12 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
         },
     }));
     /**
-     * Changed and chunk columns of components no registered system filters on are muted: nothing reads those ticks,
-     * so the WASM drops their stamps and the JS kernel stamps one dummy element. Chunk columns of components held on
-     * the GPU stay, since uploads read them.
+     * Changed, chunk and block columns of components no registered system filters on are muted: nothing reads those
+     * ticks, so the WASM drops their stamps and the JS kernel stamps one dummy element. Chunk columns of components
+     * held on the GPU stay, since uploads read them; block columns, which only filters read, go with the row ticks.
      */
     const stamped = (source: Extract<Source, { readonly id: number }>): boolean => state.observed.has(source.id) || (source.kind === "chunks" && state.resident.has(source.id));
-    const mutedNow = (): boolean[] => sources.map(source => (source.kind === "changed" || source.kind === "chunks") && !stamped(source));
+    const mutedNow = (): boolean[] => sources.map(source => (source.kind === "changed" || source.kind === "chunks" || source.kind === "blocks") && !stamped(source));
     const upWasmColumns: WasmColumn[] = upSources.map(source => {
         const layout = state.layouts[source.id];
         return { view: source.leaf.view, stride: layout.kind === "linear" ? layout.stride : 0, offset: source.leaf.offset, boolean: source.leaf.scalar === "boolean", component: source.id };
@@ -251,7 +313,8 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
     const filterCount = up !== undefined ? 0 : (query?.added?.length ?? 0) + (query?.changed?.length ?? 0);
     const generate = (muted: readonly boolean[]): WasmKernel | null => useWasm && description.program !== null
         ? generateWasm(description.program, wasmColumns.map((column, k) => muted[k] ? { ...column, muted: true } : column), scalarType, state.simd, filterCount, wasmLookups, upWasmColumns,
-            description.reductions.map(reduction => reduction.operator), indexes.map(bound => bound?.wasm ?? null), (description.probes ?? []).map(probe => probe.lookup))
+            description.reductions.map(reduction => reduction.operator), indexes.map(bound => bound?.wasm ?? null), (description.probes ?? []).map(probe => probe.lookup),
+            description.storagePrecision === true)
         : null;
     let muted = mutedNow();
     let index = state.kernelIndexes.get(description.url);
@@ -274,6 +337,10 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
         },
         upColumnsOf,
         wasm: generate(muted),
+        allPresent: archetype => {
+            for (const id of setup.optional) if (!archetype.storageOf.has(id)) return false;
+            return true;
+        },
         compiled: () => compiled,
         kernel: () => loaded ?? fail("its module isn't loaded."),
         stale: () => {
@@ -293,7 +360,7 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
             bound.setup = { ...setup, muted, up: upSetup };
             loadedFor = muted.join();
             const module: KernelModule = await import(/* @vite-ignore */ description.url);
-            loaded = module.create(booleans, strides.map((stride, k) => muted[k] ? 0 : stride), offsets.map((offset, k) => muted[k] ? 0 : offset), upSetup.booleans, upSetup.strides, upSetup.offsets);
+            loaded = module.create(booleans, strides.map((stride, k) => muted[k] ? 0 : stride), offsets.map((offset, k) => muted[k] ? 0 : offset), upSetup.booleans, upSetup.strides, upSetup.offsets, setup.labels);
             compiled = null;
             if (bound.wasm === null) return;
             try {
@@ -320,7 +387,9 @@ export const bindKernel = (state: State, leaf: Leaf, description: KernelDescript
         gpu: () => description.program === null
             ? "it issues commands or uses values that aren't numbers"
             : description.lookups.length > 0 ? "it uses lookups"
-            : generateWgsl(description.program, wasmColumns.map((column, k) => muted[k] ? { ...column, muted: true } : column), scalarType, upWasmColumns),
+            : generateWgsl(description.program, wasmColumns.map((column, k) => muted[k] ? { ...column, muted: true } : column), scalarType, upWasmColumns, scalarKind),
+        sharedOf,
+        scalarKind,
     };
     return bound;
 };

package/src/implementation/world/layout-directory.browser.test.ts

@@ -1,11 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { afterEach, describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Entity } from "../../interface/entity/entity.js";
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
 import { workers } from "../../interface/resources/workers.js";
 import { readEach, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
+import type { F32 } from "../../interface/math/index.js";
 
 const value = Symbol("layoutDirectoryTest/value");
 const target = Symbol("layoutDirectoryTest/target");
@@ -22,9 +23,9 @@ const tags = [tag0, tag1, tag2, tag3, tag4, tag5, tag6] as const;
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [value]: { type: number };
+        [value]: { type: F32 };
         [target]: { type: Entity };
-        [seen]: { type: number };
+        [seen]: { type: F32 };
         [child]: { type: true };
         [tag0]: { type: true };
         [tag1]: { type: true };
@@ -36,66 +37,54 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(value, { type: { type: "number", precision: 1 } });
-Component.register(target, { type: Entity.schema });
-Component.register(seen, { type: { type: "number", precision: 1 } });
-Component.register(child, { type: { const: true } });
-Component.register(tag0, { type: { const: true } });
-Component.register(tag1, { type: { const: true } });
-Component.register(tag2, { type: { const: true } });
-Component.register(tag3, { type: { const: true } });
-Component.register(tag4, { type: { const: true } });
-Component.register(tag5, { type: { const: true } });
-Component.register(tag6, { type: { const: true } });
 
 /** The component lists of 100 archetypes: `value` with each of the first 100 combinations of the tags. */
 const lists = Array.from({ length: 100 }, (_, i): (typeof value | (typeof tags)[number])[] => [value, ...tags.filter((_, bit) => (i & (1 << bit)) !== 0)]);
 
 /** Spawns `count` entities into each of the 100 archetypes. */
-const fill = System.create({ name: "layoutDirectoryTest/fill", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+const fill = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (const list of lists) for (let i = 0; i < input.count; i++) commands.spawn(list)({ [value]: 0 });
 });
 
-const bump = System.create({ name: "layoutDirectoryTest/bump", kernel: "cpu", components: { write: [value] } }, row => {
+const bump = System.create({ kernel: true, components: { with: [value] } }, row => {
     row[value] = row[value] + 1;
 });
 
 const total = { sum: 0, count: 0 };
 /** Sums every value on the world's thread, so it reads what workers wrote. */
-const sum = System.create({ name: "layoutDirectoryTest/sum", components: { read: [value] } }, row => {
+const sum = System.create({ components: { with: [value] } }, row => {
     total.sum += row[value];
     total.count++;
 });
 
 /** Entities whose values the lookups read, recorded as they spawn. */
 const spawned: Entity[] = [];
-const make = System.create({ name: "layoutDirectoryTest/make" }, ({ commands }) => {
+const make = System.create({}, ({ commands }) => {
     for (let i = 0; i < 64; i++) commands.spawn([target, seen])({ [target]: Entity.none, [seen]: 0 });
     commands.spawn([value])({ [value]: -1 });
 });
-const spawnMany = System.create({ name: "layoutDirectoryTest/spawnMany", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+const spawnMany = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) spawned.push(commands.spawn([value])({ [value]: i }));
 });
 /** Aims each looker at one of the last spawned entities. */
 let aimed = 0;
-const aim = System.create({ name: "layoutDirectoryTest/aim", components: { write: [target] } }, row => {
+const aim = System.create({ components: { with: [target] } }, row => {
     row[target] = spawned[spawned.length - 1 - aimed++];
 });
-const despawnValues = System.create({ name: "layoutDirectoryTest/despawnValues", components: { has: [value], not: [child] } }, (row, { commands }) => {
+const despawnValues = System.create({ components: { with: [value], not: [child] } }, (row, { commands }) => {
     commands.despawn(row.entity);
 });
 /** Lookups from workers. */
 const look = System.create({
-    name: "layoutDirectoryTest/look",
-    kernel: "cpu",
-    components: { read: [target], write: [seen] },
-    lookup: { targets: { read: [value] } },
+    kernel: true,
+    components: { with: [target, seen] },
+    lookup: { targets: { with: [value] } },
 }, (row, { lookup: { targets } }) => {
     const other = targets(row[target]);
     row[seen] = other === null ? -1 : other[value];
 });
 /** Spawns from workers: a child per looker. */
-const breed = System.create({ name: "layoutDirectoryTest/breed", kernel: "cpu", components: { read: [seen] } }, (row, { commands }) => {
+const breed = System.create({ kernel: true, components: { with: [seen] } }, (row, { commands }) => {
     commands.spawn([value, child])({ [value]: row[seen] });
 });
 
@@ -130,7 +119,8 @@ const totals = async (world: World): Promise<{ sum: number; count: number }> =>
 describe("the layout directory", () => {
     for (const wasm of [true, false]) {
         it(`lets workers' ${wasm ? "WASM" : "JS"} kernels see every row of 100 archetypes grown across sync points, with no layout message after the one creating them`, async () => {
-            const world = createWorld({ [workers]: 3 }, { minimumChunk: 16, wasm });
+            // Pieces of two rows, so the first round's single rows start the pool and its layout message is before the count.
+            const world = createWorld({ [workers]: 3 }, { minimumChunk: 2, wasm });
             disposals.push(world);
             await world.run(fill, { count: 1 });
             await world.run(bump);
@@ -177,7 +167,7 @@ describe("the layout directory", () => {
 
     for (const wasm of [true, false]) {
         it(`lets workers' ${wasm ? "WASM" : "JS"} kernels rebuild their views once memory grows between runs`, async () => {
-            const world = createWorld({ [workers]: 2 }, { minimumChunk: 16, wasm });
+            const world = createWorld({ [workers]: 2 }, { minimumChunk: 2, wasm });
             disposals.push(world);
             await world.run(fill, { count: 1 });
             await world.run(bump);

package/src/implementation/world/layout-directory.cases.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import type * as Fixture from "./layout-directory.fixture.js";