@adobe/ecs 0.1.0 → 0.2.0

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

@@ -1,9 +1,7 @@
-import { Component } from "../../interface/component/component.js";
-import { Resource } from "../../interface/resource/resource.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../../interface/system/system.js";
 import { Observe } from "../../observe/index.js";
 import type { World } from "../../interface/world/world.js";
-import { reportOf } from "./reports.test-helper.js";
 
 // Keys and systems both threads of the joining fixtures import, and the scenario a joined thread drives.
 
@@ -12,6 +10,8 @@ export const label = Symbol("joiningTest/label");
 export const marked = Symbol("joiningTest/marked");
 export const total = Symbol("joiningTest/total");
 export const names = Symbol("joiningTest/names");
+/** An object of `main`, which a thread claiming it fills. */
+export const shelf = Symbol("joiningTest/shelf");
 declare module "@adobe/ecs" {
     export interface Components {
         [point]: { type: readonly [number, number] };
@@ -20,27 +20,28 @@ declare module "@adobe/ecs" {
     }
     export interface Resources {
         [total]: { type: number };
-        [names]: { type: readonly string[] };
+        [names]: { type: readonly string[]; default: [] };
+        [shelf]: { type: readonly string[]; default: []; thread: "main" };
     }
 }
-Component.register(point, { type: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2 } });
-Component.register(label, { type: { type: "string" } });
-Component.register(marked, { type: { const: true } });
-Resource.register(total, { type: { type: "number", default: 0 } });
-Resource.register(names, { type: { type: "array", items: { type: "string" }, default: [] } });
 
-/** Appends a digit to `total`, so the order of runs shows in it. */
-export const add = System.create({ name: "joiningTest/add", input: { type: "object", properties: { amount: { type: "number" } } }, resources: { write: [total] } }, ({ input, resources }) => {
+/** Appends a digit to `total`, so the order of runs shows in it, and gives the new total. */
+export const add = System.create({}, ({ resources }, input: { readonly amount: number }) => {
     resources[total] = resources[total] * 10 + input.amount;
+    return resources[total];
 });
-export const append = System.create({ name: "joiningTest/append", input: { type: "object", properties: { name: { type: "string" } } }, resources: { write: [names] } }, ({ input, resources }) => {
+/** Appends a name, and gives how many there are. */
+export const append = System.create({}, ({ resources }, input: { readonly name: string }) => {
     resources[names] = [...resources[names], input.name];
+    return resources[names].length;
 });
-export const spawn = System.create({ name: "joiningTest/spawn", input: { type: "object", properties: { x: { type: "number" } } } }, ({ input, commands }) => {
+/** Reads `total` from an observer system, which a joined thread runs itself. */
+export const readTotal = System.create({ observer: true }, ({ resources }) => resources[total]);
+export const spawn = System.create({}, ({ commands }, input: { readonly x: number }) => {
     commands.spawn([point, label, marked])({ [point]: [input.x, -input.x], [label]: `p${input.x}` });
 });
-export const fail = System.create({ name: "joiningTest/fail" }, () => { throw new Error("joiningTest failure"); });
-export const idle = System.create({ name: "joiningTest/idle" }, () => {});
+export const fail = System.create({}, () => { throw new Error("joiningTest failure"); });
+export const idle = System.create({}, () => {});
 
 /** The first value an observer gives that `accept` takes. */
 export const until = <T>(observe: Observe<T>, accept: (value: T) => boolean): Promise<T> => new Promise(resolve => {
@@ -54,25 +55,28 @@ export const until = <T>(observe: Observe<T>, accept: (value: T) => boolean): Pr
 });
 
 /**
- * What a joined thread sees driving a world: runs in call order with struct and object input, by number, a failing
- * run's number, observers of a resource, a selection, a count and an entity's listed components, and the
- * rejections of a system the world never imported and of one without an id.
+ * What a joined thread sees driving a world: runs in call order with struct and object input, by what their bodies
+ * returned, a failing run's rejection, a read through an observer system of its own, observers of a resource, a
+ * selection, a count and an entity's listed components, and the rejections of a system the world never imported and
+ * of one without an id.
  */
 export const drive = async (remote: World, unimported: System<void>) => {
     const runs = await Promise.all([
         remote.run(add, { amount: 1 }), remote.run(append, { name: "a" }), remote.run(add, { amount: 2 }), remote.run(append, { name: "b" }), remote.run(add, { amount: 3 }),
     ]);
-    const failed = await remote.run(fail);
+    const rejected = (run: Promise<unknown>): Promise<string> => run.then(() => "ran", (error: unknown) => error instanceof Error ? error.message : String(error));
+    const failed = await rejected(remote.run(fail));
+    const read = await remote.run(readTotal);
     await remote.run(spawn, { x: 1 });
     await remote.run(spawn, { x: 2 });
     const observedTotal = await until(Observe.resource(remote, total), value => value === 123);
     const selected = await until(Observe.select(remote, { required: [point], order: { [point]: false } }), entities => entities.length === 2);
     const counted = await until(Observe.count(remote, { required: [point], where: { [point]: [2, -2] } }), count => count === 1);
     const listed = await until(Observe.entity(remote, selected[0], { required: [point], optional: [marked] }), value => value !== null);
-    const rejected = (run: Promise<unknown>): Promise<string> => run.then(() => "ran", (error: unknown) => error instanceof Error ? error.message : String(error));
     return {
         runs,
         failed,
+        read,
         total: observedTotal,
         selected: selected.length,
         counted,
@@ -83,10 +87,4 @@ export const drive = async (remote: World, unimported: System<void>) => {
 };
 export type Driven = Awaited<ReturnType<typeof drive>>;
 
-/** What a joined thread saw driving a world, its runs' reports read on the world's thread, which holds them. */
-export const withReports = async (world: World, { runs, failed, ...driven }: Driven) => ({
-    ...driven,
-    reports: await Promise.all(runs.map(run => reportOf(world, run))),
-    failures: (await reportOf(world, failed)).failures.map(failure => failure.message),
-});
-export type Reported = Awaited<ReturnType<typeof withReports>>;
+

package/src/implementation/world/joining.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { World } from '../../interface/world/world.js';
 import type { WorkerError } from './protocol.js';
 import type { Schema } from '../../interface/schema/schema.js';
@@ -25,6 +26,7 @@ export type ObserverLookup = {
     readonly name: string;
     readonly read: readonly number[];
     readonly has: readonly number[];
+    readonly optional: readonly number[];
     readonly not: readonly number[];
     /** Null where it doesn't declare `changed`. */
     readonly changed: readonly number[] | null;
@@ -33,7 +35,11 @@ export type ObserverLookup = {
 
 /** What an observer system a joined thread declares reads, by that thread's numbers for its keys. */
 export type ObserverDeclaration = {
-    readonly components: { readonly read: readonly number[]; readonly has: readonly number[]; readonly not: readonly number[]; readonly added: readonly number[]; readonly changed: readonly number[] } | null;
+    /**
+     * Its components' lists, and whether it has `where`, which runs on its thread: the world posts one with `where` and
+     * change filters after every sync point, since it keeps a point per archetype there.
+     */
+    readonly components: { readonly read: readonly number[]; readonly has: readonly number[]; readonly optional: readonly number[]; readonly not: readonly number[]; readonly added: readonly number[]; readonly changed: readonly number[]; readonly where: boolean } | null;
     readonly resources: { readonly read: readonly number[]; readonly changed: readonly number[]; readonly is: readonly number[]; readonly not: readonly number[] } | null;
     readonly lookup: readonly ObserverLookup[];
 };
@@ -77,19 +83,25 @@ export type ToWorld = { readonly protocol: typeof protocolName } & (
     | { readonly kind: "received"; readonly from: number; readonly sequence: number }
     /** Where the world can't wait without blocking: runs were posted. */
     | { readonly kind: "wake" }
+    /**
+     * Once it joined, on its first turn of its event loop after: what it did as its join resolved, observer systems it
+     * added included, came before, so the world's `share` resolves.
+     */
+    | { readonly kind: "ready" }
     | { readonly kind: "leave" }
     /**
      * After task `sequence` is done, when its completion says a message follows: its systems' errors and spilled
      * segments, by position in the task; posted after the thread's numbers for keys its commands named first. `stamps`
      * are the objects tails wrote from their snapshots, as position in the task, entity and component, which the world
-     * stamps changed at their tick.
+     * stamps changed at their tick. `values` are what bodies of systems without components returned, but undefined.
      */
     | {
         readonly kind: "completed"; readonly sequence: number;
         readonly errors: readonly (readonly [number, WorkerError])[]; readonly spills: readonly (readonly [number, Uint8Array])[];
         readonly stamps?: readonly number[];
+        readonly values?: readonly (readonly [number, unknown])[];
     }
-    /** What its finalizers threw, by their index on this thread, for the world's next report. */
+    /** What its finalizers threw, by their index on this thread, which the world reports out of band. */
     | { readonly kind: "finalized"; readonly errors: readonly (readonly [number, WorkerError])[] }
     /** It dropped what it held for the systems unplaced at these indexes, which the world may place again. */
     | { readonly kind: "unplaced"; readonly indexes: readonly number[] }
@@ -100,8 +112,13 @@ export type ToWorld = { readonly protocol: typeof protocolName } & (
     | { readonly kind: "observer"; readonly number: number; readonly name: string; readonly declaration: ObserverDeclaration; readonly added: boolean }
     /** Its observer system `number` is added to ticks, removed from them, or no longer needed, its value collected. */
     | { readonly kind: "observer add" | "observer remove" | "observer drop"; readonly number: number }
-    /** What observer systems placed on it threw, by their indexes there, for the world's next report. */
+    /** What observer systems placed on it threw, by their indexes there, which the world reports out of band. */
     | { readonly kind: "observer failed"; readonly errors: readonly (readonly [number, WorkerError])[] }
+    /**
+     * Posts owed to runs of the world's ran there, by the indexes of their systems there: what each body returned, or
+     * what it threw, which those runs resolve to or reject with.
+     */
+    | { readonly kind: "observer ran"; readonly results: readonly (readonly [number, unknown, WorkerError | null])[] }
     /** It dropped the observer systems at these indexes, which the world unplaced. */
     | { readonly kind: "observer dropped"; readonly indexes: readonly number[] }
     /** A post it claimed and couldn't run yet, owed to a run: the world posts it again between runs. */
@@ -152,7 +169,11 @@ export type ToJoined = { readonly protocol: typeof protocolName } & (
     /** A component whose objects the thread fills, by the world's number, with its id: null for one without. */
     | { readonly kind: "component"; readonly component: number; readonly id: string | null }
     | { readonly kind: "refused"; readonly message: string }
+    /** The name of the Web Lock the world's thread holds while it lives (`threadLock`), posted as it's shared and as it's asked to join. */
+    | { readonly kind: "thread lock"; readonly lock: string }
     | { readonly kind: "rejected"; readonly sequence: number; readonly message: string }
+    /** Run `sequence` resolved to `value`, a value but undefined. */
+    | { readonly kind: "resolved"; readonly sequence: number; readonly value: unknown }
     /** Where the joined thread can't wait without blocking: runs completed, or a task or observer post waits for it. */
     | { readonly kind: "wake" }
     | { readonly kind: "disposed" }
@@ -169,6 +190,16 @@ export type ThreadChannel<Send, Receive> = {
     readonly onMessage: (handler: (message: Receive) => void) => void;
     /** Sets the one handler for the other end's end: a `MessagePort`'s close, or a node worker's exit. */
     readonly onClose: (handler: () => void) => void;
+    /**
+     * Sets the one handler for a `Worker`'s `error` or `messageerror`, with its message: a worker that failed to start
+     * or threw, or a message that couldn't be read. Nothing for other ports, whose `error` is this thread's own.
+     */
+    readonly onFailure: (handler: (message: string) => void) => void;
+    /**
+     * Whether the port's other end is already closed, once `onMessage` is set: a node `MessagePort` that a listener
+     * doesn't keep alive is closed, its `close` already past. False wherever the platform doesn't tell.
+     */
+    readonly closed: () => boolean;
     /** Closes a `MessagePort`; a worker or a worker's scope stays as it is, its owner's to end. */
     readonly close: () => void;
 };
@@ -178,6 +209,19 @@ const isMessagePort = (port: Parameters<World["share"]>[0]): boolean =>
     typeof globalThis.MessagePort === "function" && port instanceof globalThis.MessagePort
     && port !== globalThis.process?.getBuiltinModule?.("node:worker_threads")?.parentPort;
 
+/** Whether a port is a `Worker`, of the browser or node, whose `error` is that worker's. */
+const isWorker = (port: Parameters<World["share"]>[0]): boolean => {
+    const browser = globalThis.Worker;
+    const node = globalThis.process?.getBuiltinModule?.("node:worker_threads")?.Worker;
+    return (typeof browser === "function" && port instanceof browser) || (typeof node === "function" && port instanceof node);
+};
+
+/** What an `error` or `messageerror` says: an `ErrorEvent`'s message, an `Error`'s, or what a message couldn't be read as. */
+const failureMessage = (value: unknown): string => {
+    const message: unknown = typeof value === "object" && value !== null ? Reflect.get(value, "message") : undefined;
+    return typeof message === "string" && message !== "" ? message : "a message couldn't be read";
+};
+
 const isOurs = (data: unknown): boolean => typeof data === "object" && data !== null && Reflect.get(data, "protocol") === protocolName;
 
 /**
@@ -218,6 +262,15 @@ export const threadChannel = <Send, Receive>(port: Parameters<World["share"]>[0]
             subscribe("close", once);
             if (typeof on === "function") subscribe("exit", once);
         },
+        onFailure: handler => {
+            if (!isWorker(port)) return;
+            subscribe("error", value => handler(failureMessage(value)));
+            subscribe("messageerror", value => handler(failureMessage(value)));
+        },
+        closed: () => {
+            const hasRef: unknown = Reflect.get(port, "hasRef");
+            return isMessagePort(port) && typeof on === "function" && typeof hasRef === "function" && Reflect.apply(hasRef, port, []) === false;
+        },
         close: () => { if (isMessagePort(port) && typeof close === "function") Reflect.apply(close, port, []); },
     };
 };
@@ -243,8 +296,8 @@ export const runSlots = 64;
 export const slotWords = 64;
 export const slotStatus = 0;
 export const slotNumber = 1;
-export const slotRun = 2;
-export const slotInput = 3;
+export const slotInput = 2;
+/** The input starts on an 8-byte boundary, as f64 views of it need. */
 export const slotPayload = 4;
 export const controlBytes = (slotsWord + runSlots * slotWords) * 4;
 /** Input written in its slot, at most this many bytes. */
@@ -258,10 +311,11 @@ export const inputByMessage = -2;
 export const inputMoved = -3;
 /** A slot's system number for a run whose input couldn't be posted, which the world completes without running. */
 export const unposted = -1;
-/** Slot statuses: in flight; done, its number in the slot; rejected, the rejection posted. */
+/** Slot statuses: in flight; done, to nothing; rejected, the rejection posted; resolved, its value posted. */
 export const pending = 0;
 export const done = 1;
 export const rejected = 2;
+export const resolved = 3;
 
 /** The schema with every number widened to f64, so a run's input crosses exactly as given. */
 const widened = (schema: Schema): Schema => {
@@ -307,3 +361,27 @@ export const slotViews = (buffer: ArrayBufferLike, control: number): readonly Vi
 
 /** The platform's Web Locks, where it has them, by which a thread that ends however it ends releases what it held. */
 export const platformLocks = (): LockManager | null => globalThis.navigator?.locks ?? null;
+
+/** A name for a Web Lock of this protocol, unique to the thread holding it. */
+export const lockName = (): string => `${protocolName}#${globalThis.crypto?.randomUUID?.() ?? String(Math.random()).slice(2)}`;
+
+let threadLockHeld: Promise<string | null> | null = null;
+
+/**
+ * The name of a Web Lock this thread holds for as long as it lives, once it holds it, where the platform's ports don't
+ * report a thread's end: a browser's. A world tells the threads joining it, which request it, so they hear of its
+ * thread's end however it ends. Null in node, whose ports close as a thread ends, and where a worker waiting for a lock
+ * the world's thread holds stalls while that thread waits for one of the worker's tasks; and where there are no locks.
+ */
+export const threadLock = (): Promise<string | null> => {
+    if (threadLockHeld !== null) return threadLockHeld;
+    const locks = globalThis.process?.versions?.node === undefined ? platformLocks() : null;
+    threadLockHeld = locks === null ? Promise.resolve(null) : new Promise(resolve => {
+        const name = lockName();
+        void locks.request(name, () => {
+            resolve(name);
+            return new Promise<void>(() => {});
+        });
+    });
+    return threadLockHeld;
+};

package/src/implementation/world/journal.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /**
  * Entity indexes whose archetype or references sync points changed: spawned, despawned, moved to another archetype,
  * or written a reference. Kept only while some reader, an `up` system or an index, needs it. Positions count every
@@ -18,14 +19,17 @@ export const createJournal = (): Journal => ({ indexes: new Int32Array(0), lengt
 export const journalEnd = (journal: Journal): number => journal.first + journal.length;
 
 /**
- * Appends an entity index, once some reader exists. Past `limit` entries the journal drops them: a reader behind
- * then rebuilds, which costs about what reading that many entries would.
+ * Appends an entity index, once some reader exists. Past `limit` entries the journal drops the older half, so a reader
+ * within half of it of the end, as one current at the last sync point usually is, reads on; a reader further behind
+ * rebuilds, which costs about what reading that many entries would.
  */
 export const record = (journal: Journal, index: number, limit: number): void => {
     if (journal.readers === 0) return;
     if (journal.length >= Math.max(4096, limit)) {
-        journal.first += journal.length;
-        journal.length = 0;
+        const kept = journal.length >> 1;
+        journal.indexes.copyWithin(0, journal.length - kept, journal.length);
+        journal.first += journal.length - kept;
+        journal.length = kept;
     }
     if (journal.length === journal.indexes.length) {
         const grown = new Int32Array(Math.max(1024, 2 * journal.indexes.length));

package/src/implementation/world/kernel-imports-sparks.test-helper.ts

@@ -1,4 +1,5 @@
-import { Archetype, Component, Vec3 } from "../../index.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Vec3 } from "../../index.js";
 
 export const position = Symbol("kernelImports/position");
 export const spark = Symbol("kernelImports/spark");
@@ -10,8 +11,6 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(position, { type: Vec3.schema });
-Component.register(spark, { type: { const: true } });
 
 /** A list a kernel imports: the build reads its components here, and compiles the kernel again when this module changes. */
-export const sparks = Archetype.create([position, spark]);
+export const sparks = [position, spark] as const;

package/src/implementation/world/kernel-imports-steer.test-helper.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Vec3 } from "../../index.js";
 
 /** A pure helper a kernel imports: the build inlines it, and it still runs as written everywhere else. */

package/src/implementation/world/kernel-imports.test.ts

@@ -1,5 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { expect, it } from "vitest";
-import { Component, Entity, System, Vec3, World } from "../../index.js";
+import { Entity, System, Vec3, World } from "../../index.js";
 import { Observe } from "../../observe/index.js";
 import { position, spark, sparks } from "./kernel-imports-sparks.test-helper.js";
 import { steer } from "./kernel-imports-steer.test-helper.js";
@@ -16,25 +17,22 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(velocity, { type: Vec3.schema });
-Component.register(target, { type: Entity.schema });
 
-const spawn = System.create({ name: "kernelImports/spawn" }, ({ commands }) => {
+const spawn = System.create({}, ({ commands }) => {
     const leader = commands.spawn([position, velocity])({ [position]: [10, 0, 0], [velocity]: [0, 0, 0] });
     commands.spawn([position, velocity, target])({ [position]: [0, 0, 0], [velocity]: [0, 0, 0], [target]: leader });
 });
 
-// `kernel: "cpu"` compiles the body at build time, to run in chunks across workers as WASM where it can.
-const integrate = System.create({ name: "kernelImports/integrate", kernel: "cpu", components: { read: [velocity], write: [position] } }, row => {
+// `kernel: true` compiles the body at build time, to run in chunks across workers as WASM where it can.
+const integrate = System.create({ kernel: true, components: { with: [velocity, position] } }, row => {
     row[position] = Vec3.add(row[position], row[velocity]);
 });
 
 // Kernels use lookups, imported pure functions, commands and imported lists too.
 const chase = System.create({
-    name: "kernelImports/chase",
-    kernel: "cpu",
-    components: { read: [position, target], write: [velocity] },
-    lookup: { targets: { read: [position] } },
+    kernel: true,
+    components: { with: [position, target, velocity] },
+    lookup: { targets: { with: [position] } },
 }, (row, { lookup, commands }) => {
     const other = lookup.targets(row[target]);
     if (other === null) return;
@@ -57,10 +55,10 @@ it("runs systems compiled as kernels", async () => {
 });
 
 // A kernel's `add` and `remove` take an imported `Symbol(...)` as one key, and an imported list as a list.
-const ignite = System.create({ name: "kernelImports/ignite" }, ({ commands }) => {
+const ignite = System.create({}, ({ commands }) => {
     commands.spawn(sparks)({ [position]: [0, 0, 0] });
 });
-const settle = System.create({ name: "kernelImports/settle", kernel: "cpu", components: { has: [spark] } }, (row, { commands }) => {
+const settle = System.create({ kernel: true, components: { with: [spark] } }, (row, { commands }) => {
     commands.remove(row.entity, spark);
 });
 

package/src/implementation/world/kernel-indexes.ts

@@ -1,9 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { samePath, type Path } from '../../interface/registry/layout.js';
 import { labelOf, watchedBy } from '../../interface/registry/index.js';
 import type { KernelDescription } from './kernel.js';
 import { partWords } from './index-keys.js';
 import { sortedStride } from './index-sorted.js';
-import { recordKey } from './index-hash.js';
+import { recordKey, sortHashTable } from './index-hash.js';
 import type { WorldIndex } from './indexes.js';
 import type { IndexReaderSetup, IndexSource, RowLeaf } from './index-readers.js';
 import { idOf, type Key, type State } from './state.js';
@@ -101,11 +102,16 @@ export const kernelIndexesOf = (state: State, description: KernelDescription, lo
         };
     });
 
-/** Writes a lookup through an index's WASM parameters into `out` from `at`, as of now: its arrays' addresses, counts and ticks. */
+/**
+ * Writes a lookup through an index's WASM parameters into `out` from `at`, as of now: its arrays' addresses, counts and
+ * ticks. A hash index's unsorted buckets are sorted first, since its reader reads entries by position where it can't
+ * sort them.
+ */
 export const writeIndexParameters = (bound: Pick<KernelIndex, "index" | "watched">, since: number, out: number[], at: number): number => {
     const { hash, sorted } = bound.index;
     let next = at;
     if (hash !== null) {
+        if (hash.unsorted !== 0) sortHashTable(hash);
         out[next++] = hash.slots.byteOffset;
         out[next++] = (hash.slots.length >> 1) - 1;
         out[next++] = hash.records.byteOffset;
@@ -132,7 +138,10 @@ export const writeIndexParameters = (bound: Pick<KernelIndex, "index" | "watched
     return next;
 };
 
-/** Points a JS reader's source at the world's index on its own thread, as of now. */
+/**
+ * Points a JS reader's source at the world's index on its own thread, as of now. `writeIndexParameters`, which each run
+ * calls with it, sorts the index's unsorted buckets in place.
+ */
 export const refreshSource = (source: IndexSource, bound: KernelIndex, since: number): void => {
     const { hash, sorted } = bound.index;
     source.since = since;

package/src/implementation/world/kernel-lookup.test-helper.ts

@@ -1,6 +1,7 @@
-import { Component } from '../../interface/component/component.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { Entity } from '../../interface/entity/entity.js';
 import { System } from '../../interface/system/system.js';
+import type { F32 } from '../../interface/math/index.js';
 
 /** A kernel whose lookup reads a value outside linear memory, which `System.create` rejects as this module runs. */
 
@@ -11,19 +12,14 @@ declare module "@adobe/ecs" {
     export interface Components {
         [target]: { type: Entity };
         [label]: { type: string };
-        [offset]: { type: number };
+        [offset]: { type: F32 };
     }
 }
-Component.register(target, { type: Entity.schema });
-Component.register(label, { type: { type: "string" } });
-Component.register(offset, { type: { type: "number", precision: 1 } });
 
 export const labels = System.create({
-    name: "kernelLookupTest/labels",
-    kernel: "cpu",
-    components: { read: [target], write: [offset] },
-    // @ts-expect-error kernel lookups read linear values
-    lookup: { named: { read: [label] } },
+    kernel: true,
+    components: { with: [target, offset] },
+    lookup: { named: { with: [label] } },
 }, (row, { lookup: { named } }) => {
     const found = named(row[target]);
     row[offset] = found === null ? 0 : +found[label];

package/src/implementation/world/kernel-path.test-helper.ts

@@ -1,4 +1,4 @@
-import { Component } from '../../interface/component/component.js';
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from '../../interface/system/system.js';
 
 /** A kernel reading a leaf its component's schema doesn't have, which registering its compiled kernel rejects as this module runs. */
@@ -11,10 +11,8 @@ declare module "@adobe/ecs" {
         [sum]: { type: number };
     }
 }
-Component.register(pair, { type: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2 } });
-Component.register(sum, { type: { type: "number" } });
 
-export const beyond = System.create({ name: "kernelPathTest/beyond", kernel: "cpu", components: { read: [pair], write: [sum] } }, row => {
+export const beyond = System.create({ kernel: true, components: { with: [pair, sum] } }, row => {
     // @ts-expect-error a pair has no third item
     row[sum] = row[pair][2];
 });

package/src/implementation/world/kernel-spawns.test.ts

@@ -1,13 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Archetype } from "../../interface/archetype/archetype.js";
-import { Component } from "../../interface/component/component.js";
 import { System } from "../../interface/system/system.js";
 import { workers } from "../../interface/resources/workers.js";
 import { count, read, readEach, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
 import { indexOf } from "./entities.js";
-import { retainedRuns } from "./reports.js";
-import { fillReports } from "./reports.test-helper.js";
+import type { F32, U32, Vec2 } from "../../interface/math/index.js";
 
 const index = Symbol("kernelSpawnsTest/index");
 const value = Symbol("kernelSpawnsTest/value");
@@ -19,60 +17,53 @@ const position = Symbol("kernelSpawnsTest/position");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [index]: { type: number };
-        [value]: { type: number };
-        [extra]: { type: number };
+        [index]: { type: U32 };
+        [value]: { type: F32 };
+        [extra]: { type: F32 };
         [flag]: { type: true };
         [made]: { type: true };
         [name]: { type: string | null };
-        [position]: { type: readonly [number, number] };
+        [position]: { type: Vec2 };
     }
 }
 
-Component.register(index, { type: { type: "integer", minimum: 0, maximum: 0xFFFFFFFF } });
-Component.register(value, { type: { type: "number", precision: 1 } });
-Component.register(extra, { type: { type: "number", precision: 1 } });
-Component.register(flag, { type: { const: true } });
-Component.register(made, { type: { const: true } });
-Component.register(name, { type: { anyOf: [{ type: "string" }, { type: "null" }] } });
-Component.register(position, { type: { type: "array", items: { type: "number", precision: 1 }, minItems: 2, maxItems: 2 } });
 
-const spawned = Archetype.create([value, made]);
+const spawned = [value, made] as const;
 
-const seed = System.create({ name: "kernelSpawnsTest/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) commands.spawn([index])({ [index]: i });
 });
 
 /** One spawn per row, from a kernel. */
-const fromKernel = System.create({ name: "kernelSpawnsTest/fromKernel", kernel: "cpu", components: { read: [index] } }, (row, { commands }) => {
+const fromKernel = System.create({ kernel: true, components: { with: [index] } }, (row, { commands }) => {
     commands.spawn(spawned)({ [value]: row[index] });
 });
 
 /** The same archetype from a main-thread system, before the kernel. */
-const fromMain = System.create({ name: "kernelSpawnsTest/fromMain", before: [fromKernel] }, ({ commands }) => {
+const fromMain = System.create({ before: [fromKernel] }, ({ commands }) => {
     for (let i = 0; i < 3; i++) commands.spawn(spawned)({ [value]: 100 + i });
 });
 
 /** Spawns, then adds to and removes from what it spawned, in the same kernel and tick. */
-const spawnAndEdit = System.create({ name: "kernelSpawnsTest/spawnAndEdit", kernel: "cpu", components: { read: [index] } }, (row, { commands }) => {
+const spawnAndEdit = System.create({ kernel: true, components: { with: [index] } }, (row, { commands }) => {
     const entity = commands.spawn([value, flag, made])({ [value]: row[index] });
     commands.add(entity, extra, row[index] * 10);
     commands.remove(entity, flag);
 });
 
 /** A spawn with a tuple, and an object component left to its start. */
-const withObjects = System.create({ name: "kernelSpawnsTest/withObjects", kernel: "cpu", components: { read: [index] } }, (row, { commands }) => {
+const withObjects = System.create({ kernel: true, components: { with: [index] } }, (row, { commands }) => {
     commands.spawn([value, position, name, made])({ [value]: row[index], [position]: [row[index], -row[index]] });
 });
 
-const despawnMade = System.create({ name: "kernelSpawnsTest/despawnMade", components: { has: [made] } }, (row, { commands }) => { commands.despawn(row.entity); });
+const despawnMade = System.create({ components: { with: [made] } }, (row, { commands }) => { commands.despawn(row.entity); });
 
 const added = { seen: 0 };
-const countAdded = System.create({ name: "kernelSpawnsTest/countAdded", components: { added: [value], has: [made] } }, () => { added.seen++; });
+const countAdded = System.create({ components: { added: [value], with: [made] } }, () => { added.seen++; });
 
 /** Each made entity's value, in storage order. */
 const madeValues: number[] = [];
-const readMade = System.create({ name: "kernelSpawnsTest/readMade", observer: true, components: { read: [value], has: [made] } }, row => { madeValues.push(row[value]); });
+const readMade = System.create({ observer: true, components: { with: [value, made] } }, row => { madeValues.push(row[value]); });
 const valuesOf = async (world: ReturnType<typeof createWorld>): Promise<number[]> => {
     madeValues.length = 0;
     await world.run(readMade);
@@ -95,7 +86,7 @@ describe("kernel spawns", () => {
     it("join main-thread spawns of the same archetype: the main thread's first, then the kernel's in row order", async () => {
         const world = createWorld({ [workers]: 0 });
         await world.run(seed, { count: 4 });
-        const frame = System.create({ name: "kernelSpawnsTest/mixed", systems: [fromKernel, fromMain] });
+        const frame = System.create({ systems: [fromKernel, fromMain] });
         await world.run(frame);
         expect(await valuesOf(world)).toEqual([100, 101, 102, 0, 1, 2, 3]);
         await world.run(frame);
@@ -132,8 +123,6 @@ describe("kernel spawns", () => {
 
     it("reuse the indexes their blocks of reservations leave unused, so a few spawns a run don't grow the entity table", async () => {
         const world = createWorld({ [workers]: 0 });
-        // Past the runs that spawn reports, which take indexes of their own.
-        await fillReports(world);
         await world.run(seed, { count: 3 });
         const seen = new Set<number>();
         for (let run = 0; run < 50; run++) {
@@ -144,7 +133,7 @@ describe("kernel spawns", () => {
             await world.run(despawnMade);
         }
         // Each run reserves a block; what it leaves unused goes back to the free list, and is taken again.
-        expect(Math.max(...seen)).toBeLessThan(retainedRuns + 32);
+        expect(Math.max(...seen)).toBeLessThan(40);
         await world.dispose();
     });
 

package/src/implementation/world/kernel-tried.test-helper.ts

@@ -0,0 +1,31 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Entity } from '../../interface/entity/entity.js';
+import { System } from '../../interface/system/system.js';
+import type { F32 } from '../../interface/math/index.js';
+
+/** Systems without a kernel flag: one that compiles, and one whose lookup reads a string, which runs as written. */
+
+const target = Symbol("kernelTriedTest/target");
+const label = Symbol("kernelTriedTest/label");
+const offset = Symbol("kernelTriedTest/offset");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [target]: { type: Entity };
+        [label]: { type: string };
+        [offset]: { type: F32 };
+    }
+}
+
+export const doubled = System.create({ components: { with: [offset] } }, row => {
+    row[offset] = row[offset] * 2;
+});
+
+export const labels = System.create({
+    components: { with: [target, offset] },
+    lookup: { named: { with: [label] } },
+}, (row, { lookup: { named } }) => {
+    const found = named(row[target]);
+    row[offset] = found === null ? 0 : found[label].length;
+});
+
+export { label, offset, target };