@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/indexes.ts

@@ -1,14 +1,16 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { IndexDefinition } from '../../interface/registry/index.js';
-import { indexDefinitionOf, indexOfLookup, labelOfItem, watchedBy, watchesEntries } from '../../interface/registry/index.js';
-import type { Failure } from '../../interface/report/failure.js';
-import type { SystemLookup } from '../../interface/system/access.js';
+import { idOrNull, indexDefinitionOf, indexOfLookup, watchedBy, watchesEntries } from '../../interface/registry/index.js';
+import type { Failure } from './failures.js';
+import type { SystemLookupLists } from '../../interface/system/access.js';
 import type { Archetype, Storage } from './archetype.js';
 import { readCell } from './cells.js';
-import { chunkShift } from './kernel.js';
+import { blockShift, chunkShift } from './kernel.js';
+import { forEachNewerRow } from './ranges.js';
 import { journalEnd } from './journal.js';
 import { encodeStored, hashWords, keyPartsOf, missing, release as releaseInterned, retain, type KeyPart } from './index-keys.js';
 import {
-    bucketFor, coverBuckets, coverEntities, createHashTable, entryWords, insertEntry, lengthOf, loadHashTable, mergeEntries, place, placeAll, recordHash,
+    bucketFor, coverBuckets, coverEntities, createHashTable, entryWords, insertEntry, lengthOf, loadHashTable, forgetUnsorted, place, placeAll, recordHash,
     recordKey, rehash, relocate, slotsHold, releaseHashTable, removeEntry, startOf, tidyHashTable, unwatchHashComponent, watchHashComponent, type HashTable,
 } from './index-hash.js';
 import { allocateArray, freeArray } from './arrays.js';
@@ -50,6 +52,11 @@ export type WorldIndex = {
      * it was built; 0 before.
      */
     changed: number;
+    /**
+     * For a sorted index, the tick of the last refresh at which an entry moved to another archetype or row with its key
+     * and place unchanged, or it was built; 0 before.
+     */
+    moved: number;
     /** By watched component: how many lookups watch it, and the tick its ticks were read up to. */
     readonly watchers: Map<number, number>;
     readonly scanned: Map<number, number>;
@@ -63,8 +70,6 @@ export type WorldIndex = {
     pending: Int32Array;
     pendingArchetypes: Int32Array;
     pendingRows: Int32Array;
-    /** What an incremental refresh changes, by bucket: removals' entity indexes and insertions' entries. */
-    operations: Int32Array;
     /** A unique index's insertions of a refresh, as bucket and entity index pairs. */
     inserted: Int32Array;
     /**
@@ -74,8 +79,6 @@ export type WorldIndex = {
     readonly built: { entries: Int32Array; keys: Uint32Array; hashes: Uint32Array; buckets: Int32Array; order: Int32Array; spare: Int32Array; readonly histogram: Int32Array };
     /** What a build across the pool lists, in the arena, kept for the next; null before the first. */
     pooled: Pooled | null;
-    /** A merge's scratch, kept for the next: by bucket, its operations' start; operations in bucket order; removals, insertions and a segment. */
-    merging: { starts: Int32Array; order: Int32Array; removed: Int32Array; added: Int32Array; segment: Int32Array };
 };
 
 /** A build across the pool's arrays in the arena (`index-build.ts`): by entry, by piece, by partition, and its plan. */
@@ -109,7 +112,7 @@ export const acquireIndex = (state: State, definition: IndexDefinition): WorldIn
     const sorted = keptSorted(definition.declaration);
     const index: WorldIndex = {
         definition,
-        label: labelOfItem(definition),
+        label: definition.name,
         users: 1,
         keys,
         has: (components?.has ?? []).map(component => idOf(state, component)),
@@ -123,6 +126,7 @@ export const acquireIndex = (state: State, definition: IndexDefinition): WorldIn
         position: -1,
         refreshed: 0,
         changed: 0,
+        moved: 0,
         watchers: new Map(),
         scanned: new Map(),
         hash: sorted ? null : createHashTable(state.memory, words),
@@ -133,11 +137,9 @@ export const acquireIndex = (state: State, definition: IndexDefinition): WorldIn
         pending: new Int32Array(64),
         pendingArchetypes: new Int32Array(64),
         pendingRows: new Int32Array(64),
-        operations: new Int32Array(64),
         inserted: new Int32Array(64),
         built: { entries: new Int32Array(0), keys: new Uint32Array(0), hashes: new Uint32Array(0), buckets: new Int32Array(0), order: new Int32Array(0), spare: new Int32Array(0), histogram: new Int32Array(sorted && words > 0 ? 65536 : 0) },
         pooled: null,
-        merging: { starts: new Int32Array(0), order: new Int32Array(0), removed: new Int32Array(0), added: new Int32Array(0), segment: new Int32Array(0) },
     };
     state.indexes.set(definition, index);
     state.journal.readers++;
@@ -194,7 +196,7 @@ const refreshMembers = (state: State, index: WorldIndex): void => {
         if (member[id] !== 0) continue;
         const archetype = archetypes[id];
         const { storageById } = archetype;
-        let holds = !archetype.resource && !(archetype.meta && index.keys.length === 0 && index.has.length === 0);
+        let holds = !archetype.resource;
         for (let k = 0; holds && k < index.keys.length; k++) holds = storageById[index.keys[k]] !== undefined;
         for (let k = 0; holds && k < index.has.length; k++) holds = storageById[index.has[k]] !== undefined;
         for (let k = 0; holds && k < index.not.length; k++) holds = storageById[index.not[k]] === undefined;
@@ -273,8 +275,10 @@ const reportConflict = (state: State, index: WorldIndex, kept: number, other: nu
     failures.push({
         kind: "index",
         name: index.label,
+        id: idOrNull(index.definition),
         message: `Index "${index.label}" is unique, and entities ${kept} and ${other} both have key ${keyText(state, index, archetype, row)}; lookups give ${kept}, the one with the lower entity index.`,
-        stack: null,
+        error: undefined,
+        subject: index,
     });
 };
 
@@ -351,20 +355,17 @@ const pend = (index: WorldIndex, entity: number, archetype: number, row: number,
 
 /** Calls `each` with every row of a storage whose `changed` tick is after `since`, a whole column a GPU kernel wrote included. */
 const changedRows = (archetype: Archetype, storage: Storage, since: number, each: (row: number) => void): void => {
-    const whole = storage.columnChanged > since;
-    const { changed, chunkChanged } = storage;
-    for (let chunk = 0, count = Math.ceil(archetype.count / 2 ** chunkShift); chunk < count; chunk++) {
-        if (!whole && !(chunkChanged[chunk] > since)) continue;
-        for (let row = chunk << chunkShift, end = Math.min(archetype.count, (chunk + 1) << chunkShift); row < end; row++) {
-            if (whole || changed[row] > since) each(row);
-        }
+    if (storage.columnChanged > since) {
+        for (let row = 0; row < archetype.count; row++) each(row);
+        return;
     }
+    forEachNewerRow(storage.changed, storage.chunkChanged, storage.blockChanged, archetype.count, since, each);
 };
 
 /** Whether a component may have been written since `since`: by a system, or by a command's value at a sync point. */
 const writtenSince = (state: State, component: number, since: number): boolean => state.written[component] > since || state.valuesWritten > since;
 
-/** Refreshes the indexes of a tier, or of the finalizers, before they run, their conflicts going in the run's report. */
+/** Refreshes the indexes of a tier, or of the finalizers, before they run, their conflicts failing the run. */
 export const refreshUses = (state: State, uses: readonly IndexUse[], pool: Pool | null = null): Promise<void> | null => {
     for (let k = 0; k < uses.length; k++) {
         const pending = refreshIndex(state, uses[k].index, uses[k].watching, state.indexFailures, pool);
@@ -433,6 +434,7 @@ const finishRefresh = async (state: State, index: WorldIndex, end: number, tick:
 /** Builds an index again: in phases, across the pool when there is one, for a large hash index keyed by structs; else here. */
 const rebuildAny = (state: State, index: WorldIndex, tick: number, failures: Failure[], pool: Pool | null): Promise<void> | null => {
     index.changed = tick;
+    index.moved = tick;
     const phased = rebuildPhased(state, index, tick, failures, pool);
     if (phased !== false) return phased;
     rebuild(state, index, tick, failures);
@@ -467,10 +469,15 @@ const refresh = (state: State, index: WorldIndex, end: number, keyed: boolean, t
                 const storage = archetype.storageById[part];
                 if (storage === undefined || !storage.ticked || !writtenSince(state, part, since)) continue;
                 const whole = storage.columnChanged > since;
-                const { changed, chunkChanged } = storage;
+                const { changed, chunkChanged, blockChanged } = storage;
                 for (let chunk = 0, chunks = Math.ceil(archetype.count / 2 ** chunkShift); chunk < chunks; chunk++) {
                     if (!whole && !(chunkChanged[chunk] > since)) continue;
                     for (let row = chunk << chunkShift, end = Math.min(archetype.count, (chunk + 1) << chunkShift); row < end; row++) {
+                        // A block no row of which changed is passed over whole.
+                        if (!whole && (row & (2 ** blockShift - 1)) === 0 && !(blockChanged[row >> blockShift] > since)) {
+                            row += 2 ** blockShift - 1;
+                            continue;
+                        }
                         if (!whole && !(changed[row] > since)) continue;
                         count = marking ? pend(index, rows[row] >>> 0, id, row, count) : list(index, rows[row] >>> 0, id, row, count);
                         if (count > most) return rebuildAny(state, index, tick, failures, pool);
@@ -487,38 +494,17 @@ const refresh = (state: State, index: WorldIndex, end: number, keyed: boolean, t
 };
 
 /**
- * A bucket at least this long takes a refresh's operations in one merge, rather than a shift each; shorter ones take
- * each as it comes.
- */
-const mergeMinimum = 64;
-
-/**
- * Files each pending entity in the bucket of its key, or none: an operation applies at once on a short bucket, and on
- * a long one waits to merge with the bucket's others. A unique index's buckets holding two entries once every
- * operation applied are conflicts.
+ * Files each pending entity in the bucket of its key, or none. A long bucket of an index that isn't unique may be left
+ * unsorted (`index-hash.ts`), so a change to it costs O(1) amortized; a unique index's stay sorted, and its buckets
+ * holding two entries once every change applied are conflicts.
  */
 const patch = (state: State, index: WorldIndex, hash: HashTable, count: number, tick: number, failures: Failure[]): void => {
     const { pending, key, words, pendingArchetypes, pendingRows } = index;
     const { entities } = state;
     coverEntities(hash, entities.length);
-    // Each waiting operation: bucket, entity index, archetype id or -1 for a removal, row.
-    let waiting = 0;
-    const wait = (bucket: number, entity: number, archetype: number, row: number): void => {
-        if (4 * (waiting + 1) > index.operations.length) index.operations = fit(index.operations, 4 * (waiting + 1));
-        const at = 4 * waiting++;
-        index.operations[at] = bucket;
-        index.operations[at + 1] = entity;
-        index.operations[at + 2] = archetype;
-        index.operations[at + 3] = row;
-    };
+    const unsorting = !index.unique;
     // A unique index's insertions, as bucket and entity index pairs, checked once all apply.
     let inserted = 0;
-    const remove = (bucket: number, entity: number): void => {
-        index.changed = tick;
-        holdKey(hash, index, bucket, false);
-        if (lengthOf(hash, bucket) >= mergeMinimum) wait(bucket, entity, -1, 0);
-        else removeEntry(hash, bucket, entity, tick);
-    };
     for (let k = 0; k < count; k++) {
         const entity = pending[k];
         const scanned = pendingArchetypes[k];
@@ -526,7 +512,9 @@ const patch = (state: State, index: WorldIndex, hash: HashTable, count: number,
         const old = hash.bucketOf[entity];
         if (archetypeId < 0 || index.member[archetypeId] !== 1) {
             if (old < 0) continue;
-            remove(old, entity);
+            index.changed = tick;
+            holdKey(hash, index, old, false);
+            removeEntry(hash, old, entity, tick, unsorting);
             hash.bucketOf[entity] = -1;
             continue;
         }
@@ -543,9 +531,11 @@ const patch = (state: State, index: WorldIndex, hash: HashTable, count: number,
         }
         if (!fresh) holdKey(hash, index, bucket, true);
         index.changed = tick;
-        if (old >= 0) remove(old, entity);
-        if (lengthOf(hash, bucket) >= mergeMinimum) wait(bucket, entity, archetypeId, row);
-        else insertEntry(hash, bucket, entity, archetypeId, row, tick);
+        if (old >= 0) {
+            holdKey(hash, index, old, false);
+            removeEntry(hash, old, entity, tick, unsorting);
+        }
+        insertEntry(hash, bucket, entity, archetypeId, row, tick, unsorting);
         hash.bucketOf[entity] = bucket;
         if (index.unique) {
             if (2 * (inserted + 1) > index.inserted.length) index.inserted = fit(index.inserted, 2 * (inserted + 1));
@@ -553,7 +543,6 @@ const patch = (state: State, index: WorldIndex, hash: HashTable, count: number,
             index.inserted[2 * inserted++ + 1] = entity;
         }
     }
-    if (waiting > 0) merge(index, hash, waiting, tick);
     for (let k = 0; k < inserted; k++) {
         const bucket = index.inserted[2 * k];
         if (lengthOf(hash, bucket) > 1 && hash.bucketOf[index.inserted[2 * k + 1]] === bucket) conflict(state, index, hash, bucket, index.inserted[2 * k + 1], failures);
@@ -596,7 +585,7 @@ const patchSorted = (state: State, index: WorldIndex, sorted: SortedTable, count
         const fresh = index.objects && unknownValue(index, key);
         if (fresh) encodeRow(index, archetype, row, key, 0, true);
         if (old >= 0 && !fresh && sameStoredKey(sorted, old, key, 0)) {
-            relocateSorted(sorted, entity, archetypeId, row);
+            if (relocateSorted(sorted, entity, archetypeId, row)) index.moved = tick;
             continue;
         }
         if (objects && !fresh) holdWords(index, key, 0, true);
@@ -614,59 +603,6 @@ const patchSorted = (state: State, index: WorldIndex, sorted: SortedTable, count
     for (let k = 0; k < inserted; k++) sortedConflict(state, index, sorted, index.inserted[k], failures);
 };
 
-/** Applies the operations long buckets wait with, each bucket's in one merge, in entity order. */
-const merge = (index: WorldIndex, hash: HashTable, count: number, tick: number): void => {
-    const operations = index.operations;
-    const merging = index.merging;
-    // By bucket, counted then placed, in the order they came; then each bucket's by entity index.
-    if (merging.starts.length < hash.count + 1) merging.starts = new Int32Array(Math.max(hash.count + 1, 2 * merging.starts.length));
-    if (merging.order.length < count) {
-        const length = Math.max(count, 2 * merging.order.length);
-        merging.order = new Int32Array(length);
-        merging.removed = new Int32Array(length);
-        merging.added = new Int32Array(length * entryWords);
-    }
-    const { starts, order, removed, added } = merging;
-    starts.fill(0, 0, hash.count + 1);
-    for (let k = 0; k < count; k++) starts[operations[4 * k] + 1]++;
-    for (let bucket = 0; bucket < hash.count; bucket++) starts[bucket + 1] += starts[bucket];
-    for (let k = 0; k < count; k++) order[starts[operations[4 * k]]++] = k;
-    let scratch = merging.segment;
-    for (let start = 0; start < count;) {
-        const bucket = operations[4 * order[start]];
-        let end = start + 1;
-        while (end < count && operations[4 * order[end]] === bucket) end++;
-        // Insertion sort by entity index: a bucket's operations of one refresh are few.
-        for (let k = start + 1; k < end; k++) {
-            const moved = order[k];
-            const entity = operations[4 * moved + 1];
-            let at = k;
-            while (at > start && operations[4 * order[at - 1] + 1] > entity) {
-                order[at] = order[at - 1];
-                at--;
-            }
-            order[at] = moved;
-        }
-        let removals = 0;
-        let insertions = 0;
-        for (let k = start; k < end; k++) {
-            const at = 4 * order[k];
-            if (operations[at + 2] < 0) removed[removals++] = operations[at + 1];
-            else {
-                added[insertions * entryWords] = operations[at + 1];
-                added[insertions * entryWords + 1] = operations[at + 2];
-                added[insertions * entryWords + 2] = operations[at + 3];
-                insertions++;
-            }
-        }
-        const length = lengthOf(hash, bucket) * entryWords;
-        if (scratch.length < length) scratch = new Int32Array(Math.max(length, 2 * scratch.length));
-        mergeEntries(hash, bucket, removed, removals, added, insertions, scratch, tick);
-        start = end;
-    }
-    merging.segment = scratch;
-};
-
 /** Builds an index from every entity it holds, in entity order. */
 const rebuild = (state: State, index: WorldIndex, tick: number, failures: Failure[]): void => {
     refreshMembers(state, index);
@@ -874,6 +810,7 @@ const startBuild = (state: State, index: WorldIndex, hash: HashTable, total: num
     const entityEnd = entities.length;
     const pieces = Math.ceil(entityEnd / pieceEntities);
     coverEntities(hash, entityEnd);
+    forgetUnsorted(hash);
     // Sized for as many buckets as it last held, as `loadHashTable` sizes it.
     rehash(hash, Math.min(total, Math.max(16, hash.count - hash.freed.length - hash.empty)));
     const pooled = pooledFor(state, index, total, pieces);
@@ -1059,6 +996,8 @@ const sortedOrder = (index: WorldIndex, count: number, keys: Uint32Array): Int32
         order.set(ordered);
         return order;
     }
+    // Entries already in key order, as a load in document order lists them, need no sort.
+    if (inKeyOrder(keys, count, words)) return order;
     const histogram = built.histogram;
     for (let w = words - 1; w >= 0; w--) {
         for (let shift = 0; shift < 32; shift += 16) {
@@ -1086,6 +1025,21 @@ const sortedOrder = (index: WorldIndex, count: number, keys: Uint32Array): Int32
     return order;
 };
 
+/** Whether each of `count` entries' keys, `words` each, is at least the one before, comparing words from the first. */
+const inKeyOrder = (keys: Uint32Array, count: number, words: number): boolean => {
+    for (let k = 1; k < count; k++) {
+        const previous = (k - 1) * words;
+        const next = k * words;
+        for (let w = 0; w < words; w++) {
+            const a = keys[previous + w];
+            const b = keys[next + w];
+            if (a < b) break;
+            if (a > b) return false;
+        }
+    }
+    return true;
+};
+
 /** Stamps the buckets holding rows whose watched component changed since it was last read, with `tick`. */
 const scanWatched = (state: State, index: WorldIndex, component: number, tick: number): void => {
     const since = index.scanned.get(component) ?? tick;
@@ -1149,7 +1103,7 @@ const noFilters: readonly WorldIndex[] = [];
 const noLookups: IndexLookups = { byName: noIndexes, ordered: null, uses: noUses, filters: noFilters, release: () => {} };
 
 /** Acquires the indexes a declaration's lookups go through, watching what they watch, once each per index. */
-export const acquireLookups = (state: State, lookup: { readonly [name: string]: SystemLookup } | undefined, order?: unknown): IndexLookups => {
+export const acquireLookups = (state: State, lookup: { readonly [name: string]: SystemLookupLists } | undefined, order?: unknown): IndexLookups => {
     const ordering = indexDefinitionOf(order) ?? null;
     if (lookup === undefined && ordering === null) return noLookups;
     const byName = new Map<string, WorldIndex>();

package/src/implementation/world/input.ts

@@ -1,8 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Leaf } from '../../interface/system/leaf.js';
 
 /** The fields of a run's input that a leaf declares, so other members' fields aren't copied to its workers. */
 export const inputFor = (leaf: Leaf): (input: unknown) => unknown => {
-    const { input } = leaf.declaration;
+    const { input } = leaf;
     if (input === undefined) return () => undefined;
     const fields = Object.keys(input.properties);
     return value => {

package/src/implementation/world/intrinsics-coverage.test.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
 import { readdirSync, readFileSync } from 'node:fs';
 import { join, relative } from 'node:path';

package/src/implementation/world/intrinsics.browser.test.ts

@@ -1,11 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { F32, Mat4x4, Quat, U32, Vec2, Vec3, Vec4 } from "../../interface/math/index.js";
 import { System } from "../../interface/system/system.js";
 import { readEach, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
 import { gpuDevice } from "../../interface/resources/gpu-device.js";
 import { workers } from "../../interface/resources/workers.js";
+import { gpu } from "./gpu.test-helper.js";
 
 const f2a = Symbol("intrinsicsTest/f2a");
 const f2b = Symbol("intrinsicsTest/f2b");
@@ -91,45 +92,6 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(f2a, { type: Vec2.schema });
-Component.register(f2b, { type: Vec2.schema });
-Component.register(f2p, { type: Vec2.schema });
-Component.register(f2o, { type: Vec2.schema });
-Component.register(i2a, { type: Vec2.I32.schema });
-Component.register(u2a, { type: Vec2.U32.schema });
-Component.register(i2b, { type: Vec2.I32.schema });
-Component.register(u2b, { type: Vec2.U32.schema });
-Component.register(i2o, { type: Vec2.I32.schema });
-Component.register(u2o, { type: Vec2.U32.schema });
-Component.register(f3a, { type: Vec3.schema });
-Component.register(f3b, { type: Vec3.schema });
-Component.register(f3p, { type: Vec3.schema });
-Component.register(f3o, { type: Vec3.schema });
-Component.register(i3a, { type: Vec3.I32.schema });
-Component.register(u3a, { type: Vec3.U32.schema });
-Component.register(i3b, { type: Vec3.I32.schema });
-Component.register(u3b, { type: Vec3.U32.schema });
-Component.register(i3o, { type: Vec3.I32.schema });
-Component.register(u3o, { type: Vec3.U32.schema });
-Component.register(f4a, { type: Vec4.schema });
-Component.register(f4b, { type: Vec4.schema });
-Component.register(f4p, { type: Vec4.schema });
-Component.register(f4o, { type: Vec4.schema });
-Component.register(i4a, { type: Vec4.I32.schema });
-Component.register(u4a, { type: Vec4.U32.schema });
-Component.register(i4b, { type: Vec4.I32.schema });
-Component.register(u4b, { type: Vec4.U32.schema });
-Component.register(i4o, { type: Vec4.I32.schema });
-Component.register(u4o, { type: Vec4.U32.schema });
-Component.register(fo, { type: F32.schema });
-Component.register(ma, { type: Mat4x4.schema });
-Component.register(mb, { type: Mat4x4.schema });
-Component.register(mo, { type: Mat4x4.schema });
-Component.register(qa, { type: Quat.schema });
-Component.register(qb, { type: Quat.schema });
-Component.register(qo, { type: Quat.schema });
-Component.register(ua, { type: U32.schema });
-Component.register(uo, { type: U32.schema });
 
 /** A value in [-1, 1) that differs per row and lane. */
 const unit = (row: number, lane: number): number => ((Math.imul(row * 31 + lane * 7 + 1, 0x9E3779B9) >>> 0) / 2 ** 32) * 2 - 1;
@@ -142,7 +104,7 @@ const three = (row: number, value: (row: number, lane: number) => number): reado
 const four = (row: number, value: (row: number, lane: number) => number): readonly [number, number, number, number] => [value(row, 0), value(row, 1), value(row, 2), value(row, 3)];
 const rows = 64;
 
-const spawn = System.create({ name: "intrinsicsTest/spawn" }, ({ commands }) => {
+const spawn = System.create({}, ({ commands }) => {
     for (let i = 0; i < rows; i++) {
         commands.spawn([f2a, f2b, f2p, f2o, i2a, i2b, i2o, u2a, u2b, u2o, f3a, f3b, f3p, f3o, i3a, i3b, i3o, u3a, u3b, u3o, f4a, f4b, f4p, f4o, i4a, i4b, i4o, u4a, u4b, u4o, fo, ma, mb, mo, qa, qb, qo, ua, uo])({
             [f2a]: two(i, float(0)),
@@ -188,9 +150,7 @@ const spawn = System.create({ name: "intrinsicsTest/spawn" }, ({ commands }) =>
     }
 });
 
-const operation = { type: "object", properties: { op: { type: "number" } } } as const;
-
-const vec2f = System.create({ name: "intrinsicsTest/vec2f", kernel: "gpu", input: operation, components: { read: [f2a, f2b, f2p], write: [f2o] } }, (row, { input: { op } }) => {
+const vec2f = System.create({ kernel: "gpu", components: { with: [f2a, f2b, f2p, f2o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[f2a];
     const b = row[f2b];
     const p = row[f2p];
@@ -235,7 +195,7 @@ const vec2f = System.create({ name: "intrinsicsTest/vec2f", kernel: "gpu", input
     else if (op === 38) row[f2o] = Vec2.faceforward(a, b, p);
 });
 
-const vec2fScalar = System.create({ name: "intrinsicsTest/vec2fScalar", kernel: "gpu", input: operation, components: { read: [f2a, f2b], write: [fo] } }, (row, { input: { op } }) => {
+const vec2fScalar = System.create({ kernel: "gpu", components: { with: [f2a, f2b, fo] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[f2a];
     const b = row[f2b];
     if (op === 0) row[fo] = Vec2.dot(a, b);
@@ -243,7 +203,7 @@ const vec2fScalar = System.create({ name: "intrinsicsTest/vec2fScalar", kernel:
     else if (op === 2) row[fo] = Vec2.length(a);
 });
 
-const vec2i = System.create({ name: "intrinsicsTest/vec2i", kernel: "gpu", input: operation, components: { read: [i2a, i2b], write: [i2o] } }, (row, { input: { op } }) => {
+const vec2i = System.create({ kernel: "gpu", components: { with: [i2a, i2b, i2o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[i2a];
     const b = row[i2b];
     if (op === 0) row[i2o] = Vec2.I32.add(a, b);
@@ -264,7 +224,7 @@ const vec2i = System.create({ name: "intrinsicsTest/vec2i", kernel: "gpu", input
     else if (op === 15) row[i2o] = Vec2.I32.clamp(a, [-1000, -1000], [1000, 1000]);
 });
 
-const vec2u = System.create({ name: "intrinsicsTest/vec2u", kernel: "gpu", input: operation, components: { read: [u2a, u2b], write: [u2o] } }, (row, { input: { op } }) => {
+const vec2u = System.create({ kernel: "gpu", components: { with: [u2a, u2b, u2o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[u2a];
     const b = row[u2b];
     if (op === 0) row[u2o] = Vec2.U32.add(a, b);
@@ -283,7 +243,7 @@ const vec2u = System.create({ name: "intrinsicsTest/vec2u", kernel: "gpu", input
     else if (op === 13) row[u2o] = Vec2.U32.clamp(a, [1000, 1000], [100000, 100000]);
 });
 
-const vec3f = System.create({ name: "intrinsicsTest/vec3f", kernel: "gpu", input: operation, components: { read: [f3a, f3b, f3p], write: [f3o] } }, (row, { input: { op } }) => {
+const vec3f = System.create({ kernel: "gpu", components: { with: [f3a, f3b, f3p, f3o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[f3a];
     const b = row[f3b];
     const p = row[f3p];
@@ -330,7 +290,7 @@ const vec3f = System.create({ name: "intrinsicsTest/vec3f", kernel: "gpu", input
     else if (op === 40) row[f3o] = Vec3.faceforward(a, b, p);
 });
 
-const vec3fScalar = System.create({ name: "intrinsicsTest/vec3fScalar", kernel: "gpu", input: operation, components: { read: [f3a, f3b], write: [fo] } }, (row, { input: { op } }) => {
+const vec3fScalar = System.create({ kernel: "gpu", components: { with: [f3a, f3b, fo] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[f3a];
     const b = row[f3b];
     if (op === 0) row[fo] = Vec3.dot(a, b);
@@ -338,7 +298,7 @@ const vec3fScalar = System.create({ name: "intrinsicsTest/vec3fScalar", kernel:
     else if (op === 2) row[fo] = Vec3.length(a);
 });
 
-const vec3i = System.create({ name: "intrinsicsTest/vec3i", kernel: "gpu", input: operation, components: { read: [i3a, i3b], write: [i3o] } }, (row, { input: { op } }) => {
+const vec3i = System.create({ kernel: "gpu", components: { with: [i3a, i3b, i3o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[i3a];
     const b = row[i3b];
     if (op === 0) row[i3o] = Vec3.I32.add(a, b);
@@ -360,7 +320,7 @@ const vec3i = System.create({ name: "intrinsicsTest/vec3i", kernel: "gpu", input
     else if (op === 16) row[i3o] = Vec3.I32.clamp(a, [-1000, -1000, -1000], [1000, 1000, 1000]);
 });
 
-const vec3u = System.create({ name: "intrinsicsTest/vec3u", kernel: "gpu", input: operation, components: { read: [u3a, u3b], write: [u3o] } }, (row, { input: { op } }) => {
+const vec3u = System.create({ kernel: "gpu", components: { with: [u3a, u3b, u3o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[u3a];
     const b = row[u3b];
     if (op === 0) row[u3o] = Vec3.U32.add(a, b);
@@ -380,7 +340,7 @@ const vec3u = System.create({ name: "intrinsicsTest/vec3u", kernel: "gpu", input
     else if (op === 14) row[u3o] = Vec3.U32.clamp(a, [1000, 1000, 1000], [100000, 100000, 100000]);
 });
 
-const vec4f = System.create({ name: "intrinsicsTest/vec4f", kernel: "gpu", input: operation, components: { read: [f4a, f4b, f4p], write: [f4o] } }, (row, { input: { op } }) => {
+const vec4f = System.create({ kernel: "gpu", components: { with: [f4a, f4b, f4p, f4o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[f4a];
     const b = row[f4b];
     const p = row[f4p];
@@ -426,7 +386,7 @@ const vec4f = System.create({ name: "intrinsicsTest/vec4f", kernel: "gpu", input
     else if (op === 39) row[f4o] = Vec4.faceforward(a, b, p);
 });
 
-const vec4fScalar = System.create({ name: "intrinsicsTest/vec4fScalar", kernel: "gpu", input: operation, components: { read: [f4a, f4b], write: [fo] } }, (row, { input: { op } }) => {
+const vec4fScalar = System.create({ kernel: "gpu", components: { with: [f4a, f4b, fo] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[f4a];
     const b = row[f4b];
     if (op === 0) row[fo] = Vec4.dot(a, b);
@@ -434,7 +394,7 @@ const vec4fScalar = System.create({ name: "intrinsicsTest/vec4fScalar", kernel:
     else if (op === 2) row[fo] = Vec4.length(a);
 });
 
-const vec4i = System.create({ name: "intrinsicsTest/vec4i", kernel: "gpu", input: operation, components: { read: [i4a, i4b], write: [i4o] } }, (row, { input: { op } }) => {
+const vec4i = System.create({ kernel: "gpu", components: { with: [i4a, i4b, i4o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[i4a];
     const b = row[i4b];
     if (op === 0) row[i4o] = Vec4.I32.add(a, b);
@@ -456,7 +416,7 @@ const vec4i = System.create({ name: "intrinsicsTest/vec4i", kernel: "gpu", input
     else if (op === 16) row[i4o] = Vec4.I32.clamp(a, [-1000, -1000, -1000, -1000], [1000, 1000, 1000, 1000]);
 });
 
-const vec4u = System.create({ name: "intrinsicsTest/vec4u", kernel: "gpu", input: operation, components: { read: [u4a, u4b], write: [u4o] } }, (row, { input: { op } }) => {
+const vec4u = System.create({ kernel: "gpu", components: { with: [u4a, u4b, u4o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[u4a];
     const b = row[u4b];
     if (op === 0) row[u4o] = Vec4.U32.add(a, b);
@@ -476,7 +436,7 @@ const vec4u = System.create({ name: "intrinsicsTest/vec4u", kernel: "gpu", input
     else if (op === 14) row[u4o] = Vec4.U32.clamp(a, [1000, 1000, 1000, 1000], [100000, 100000, 100000, 100000]);
 });
 
-const mat4x4 = System.create({ name: "intrinsicsTest/mat4x4", kernel: "gpu", input: operation, components: { read: [ma, mb], write: [mo] } }, (row, { input: { op } }) => {
+const mat4x4 = System.create({ kernel: "gpu", components: { with: [ma, mb, mo] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[ma];
     const b = row[mb];
     if (op === 0) row[mo] = Mat4x4.multiply(a, b);
@@ -486,18 +446,18 @@ const mat4x4 = System.create({ name: "intrinsicsTest/mat4x4", kernel: "gpu", inp
     else if (op === 4) row[mo] = Mat4x4.scale(a, 0.5);
 });
 
-const mat4x4Vector = System.create({ name: "intrinsicsTest/mat4x4Vector", kernel: "gpu", input: operation, components: { read: [ma, f4a], write: [f4o] } }, (row, { input: { op } }) => {
+const mat4x4Vector = System.create({ kernel: "gpu", components: { with: [ma, f4a, f4o] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[ma];
     const b = row[f4a];
     if (op === 0) row[f4o] = Mat4x4.multiplyVec4(a, b);
 });
 
-const mat4x4Scalar = System.create({ name: "intrinsicsTest/mat4x4Scalar", kernel: "gpu", input: operation, components: { read: [ma], write: [fo] } }, (row, { input: { op } }) => {
+const mat4x4Scalar = System.create({ kernel: "gpu", components: { with: [ma, fo] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[ma];
     if (op === 0) row[fo] = Mat4x4.determinant(a);
 });
 
-const quat = System.create({ name: "intrinsicsTest/quat", kernel: "gpu", input: operation, components: { read: [qa, qb], write: [qo] } }, (row, { input: { op } }) => {
+const quat = System.create({ kernel: "gpu", components: { with: [qa, qb, qo] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[qa];
     const b = row[qb];
     if (op === 0) row[qo] = Quat.add(a, b);
@@ -506,14 +466,14 @@ const quat = System.create({ name: "intrinsicsTest/quat", kernel: "gpu", input:
     else if (op === 3) row[qo] = Quat.negate(a);
 });
 
-const quatScalar = System.create({ name: "intrinsicsTest/quatScalar", kernel: "gpu", input: operation, components: { read: [qa, qb], write: [fo] } }, (row, { input: { op } }) => {
+const quatScalar = System.create({ kernel: "gpu", components: { with: [qa, qb, fo] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[qa];
     const b = row[qb];
     if (op === 0) row[fo] = Quat.dot(a, b);
     else if (op === 1) row[fo] = Quat.length(a);
 });
 
-const u32 = System.create({ name: "intrinsicsTest/u32", kernel: "gpu", input: operation, components: { read: [ua], write: [uo] } }, (row, { input: { op } }) => {
+const u32 = System.create({ kernel: "gpu", components: { with: [ua, uo] } }, (row, _context, { op }: { readonly op: number }) => {
     const a = row[ua];
     if (op === 0) row[uo] = U32.countLeadingZeros(a);
     else if (op === 1) row[uo] = U32.countOneBits(a);
@@ -558,7 +518,7 @@ const device = async (): Promise<GPUDevice> => {
 };
 
 describe("declared WGSL builtins", () => {
-    it("give on the GPU what their functions give on the CPU", async () => {
+    it.runIf(gpu)("give on the GPU what their functions give on the CPU", async () => {
         const gpuWorld = createWorld({ [gpuDevice]: await device() });
         const cpuWorld = createWorld({ [workers]: 0 });
         for (const world of [gpuWorld, cpuWorld]) {

package/src/implementation/world/intrinsics.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Program } from './kernel.js';
 
 type Expression = Program.Expression;