@adobe/ecs 0.1.0 → 0.2.0

package/src/perftest/finalized.ts

@@ -1,45 +1,81 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
-import { Component } from "../interface/component/component.js";
 import { Finalizer } from "../interface/finalizer/finalizer.js";
 import { workers } from "../interface/resources/workers.js";
 import { System } from "../interface/system/system.js";
 import { createWorld, type CreatedWorld } from "../implementation/index.js";
 import type { Benchmark } from "./benchmark.js";
-import { runReported } from "../implementation/world/reports.test-helper.js";
+import { runReported } from "../implementation/world/outcomes.test-helper.js";
+import type { Vec3 } from "../interface/math/index.js";
 
 // Despawning entities whose objects a joined thread fills, with a finalizer on that thread: the world's thread writes
 // each stop's declared struct reads into the thread's stop list and doesn't wait for it. The joined thread is
-// `joined.ts`, which imports this module, so it runs the finalizer.
+// `joined.ts`, which imports this module, so it runs the finalizers. A second finalizer, over other entities, reads a
+// string resource too, and a third two linear resources, which each sync point's stop list holds copies of.
 
 const spot = Symbol("finalized/spot");
 const handle = Symbol("finalized/handle");
+const noted = Symbol("finalized/noted");
+const note = Symbol("finalized/note");
+const measured = Symbol("finalized/measured");
+const scale = Symbol("finalized/scale");
+const offset = Symbol("finalized/offset");
 declare module "@adobe/ecs" {
     export interface Threads {
         finalizedBenchmark: true;
     }
     export interface Components {
-        [spot]: { type: readonly [number, number, number] };
+        [spot]: { type: Vec3 };
         [handle]: { type: { readonly release: () => void } | null; thread: "finalizedBenchmark" };
+        [noted]: { type: { readonly release: () => void } | null; thread: "finalizedBenchmark" };
+        [measured]: { type: { readonly release: () => void } | null; thread: "finalizedBenchmark" };
+    }
+    export interface Resources {
+        [note]: { type: string; default: "released" };
+        [scale]: { type: number; default: 1 };
+        [offset]: { type: Vec3 };
     }
 }
-Component.register(spot, { type: { type: "array", items: { type: "number", precision: 1 }, minItems: 3, maxItems: 3 } });
 /** An object of the joined thread, as a DOM node or a GPU handle is. */
-Component.register(handle, { thread: "finalizedBenchmark" });
 
 /** Entities each timed sync point despawns. */
 export const despawnedObjects = 10_000;
 
 /** On the joined thread: what the finalizer released. */
 export const releases = { count: 0 };
-export const release = Finalizer.create({ name: "finalized/release", components: { read: [handle, spot] } }, row => {
+export const release = Finalizer.create({ components: { with: [handle, spot] } }, row => {
     row[handle]?.release();
     if (row[spot][0] >= 0) releases.count++;
 });
 
-const spawn = System.create({ name: "finalized/spawn" }, ({ commands }) => {
+/** On the joined thread: the same, reading the world's string resource too. */
+export const releaseNoted = Finalizer.create({ components: { with: [noted, spot] } }, (row, { resources }) => {
+    row[noted]?.release();
+    if (row[spot][0] >= 0 && resources[note].length > 0) releases.count++;
+});
+
+/** On the joined thread: the same, reading two linear resources of the world's too. */
+export const releaseMeasured = Finalizer.create({ components: { with: [measured, spot] } }, (row, { resources }) => {
+    row[measured]?.release();
+    if (row[spot][0] * resources[scale] + resources[offset][0] >= 0) releases.count++;
+});
+
+const spawn = System.create({}, ({ commands }) => {
     for (let k = 0; k < despawnedObjects; k++) commands.spawn([spot, handle])({ [spot]: [k, 0, 0], [handle]: null });
 });
-const despawn = System.create({ name: "finalized/despawn", components: { has: [handle, spot] } }, (row, { commands }) => {
+const despawn = System.create({ kernel: false, components: { with: [handle, spot] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+});
+const spawnNoted = System.create({}, ({ commands }) => {
+    for (let k = 0; k < despawnedObjects; k++) commands.spawn([spot, noted])({ [spot]: [k, 0, 0], [noted]: null });
+});
+const spawnMeasured = System.create({}, ({ commands }) => {
+    for (let k = 0; k < despawnedObjects; k++) commands.spawn([spot, measured])({ [spot]: [k, 0, 0], [measured]: null });
+});
+const despawnMeasured = System.create({ kernel: false, components: { with: [measured, spot] } }, (row, { commands }) => {
+    commands.despawn(row.entity);
+});
+const despawnNoted = System.create({ kernel: false, components: { with: [noted, spot] } }, (row, { commands }) => {
     commands.despawn(row.entity);
 });
 
@@ -49,9 +85,10 @@ const joinedFile = "./joined.js";
 const startClaiming = async (world: CreatedWorld): Promise<{ readonly terminate: () => Promise<void> }> => {
     const message = (port: unknown) => ({ kind: "port", port, threads: ["finalizedBenchmark"] });
     let terminate: () => Promise<void>;
+    let shared: Promise<void>;
     if (typeof globalThis.Worker === "function") {
         const { port1, port2 } = new MessageChannel();
-        world.share(port1);
+        shared = world.share(port1);
         const worker = new globalThis.Worker(new URL("./joined.js", import.meta.url), { type: "module" });
         await new Promise(resolve => {
             worker.onmessage = resolve;
@@ -62,7 +99,7 @@ const startClaiming = async (world: CreatedWorld): Promise<{ readonly terminate:
     else {
         const threads = globalThis.process.getBuiltinModule("node:worker_threads");
         const { port1, port2 } = new threads.MessageChannel();
-        world.share(port1);
+        shared = world.share(port1);
         const worker = new threads.Worker(new URL(joinedFile, import.meta.url));
         await new Promise(resolve => {
             worker.once("message", resolve);
@@ -70,15 +107,7 @@ const startClaiming = async (world: CreatedWorld): Promise<{ readonly terminate:
         });
         terminate = async () => { await worker.terminate(); };
     }
-    await new Promise<void>(resolve => {
-        let done = false;
-        const stop = world.threads(threads => {
-            if (done || threads.at(-1)?.status !== "joined") return;
-            done = true;
-            queueMicrotask(() => stop());
-            resolve();
-        });
-    });
+    await shared;
     return { terminate };
 };
 
@@ -86,15 +115,15 @@ const startClaiming = async (world: CreatedWorld): Promise<{ readonly terminate:
  * The fastest of `rounds` sync points despawning `despawnedObjects` entities holding the joined thread's objects,
  * timed on the world's thread, each after a spawn and a pause in which the thread finalizes the last.
  */
-const despawnObjects = async (rounds = 30): Promise<number> => {
+const despawnObjects = async (spawning: typeof spawn = spawn, despawning: typeof despawn = despawn, rounds = 30): Promise<number> => {
     const world = createWorld({ [workers]: 0 });
     const joined = await startClaiming(world);
     let best = Infinity;
     try {
         for (let round = 0; round < rounds; round++) {
-            await world.run(spawn);
+            await world.run(spawning);
             const start = performance.now();
-            const report = await runReported(world, despawn);
+            const report = await runReported(world, despawning);
             const time = performance.now() - start;
             if (report.failures.length > 0) throw new Error(`despawn objects: ${report.failures[0].message}`);
             if (round > 1) best = Math.min(best, time);
@@ -103,8 +132,9 @@ const despawnObjects = async (rounds = 30): Promise<number> => {
         }
     }
     finally {
-        await joined.terminate();
+        // Disposed first: ticks after the thread ended would fail its systems, reported out of band.
         await world.dispose();
+        await joined.terminate();
     }
     return best;
 };
@@ -119,4 +149,22 @@ export const finalizedBenchmarks: readonly Benchmark[] = [
         best: { bytes: 56, basis: "Each despawn frees its 8-byte location and entity, and writes its stop: its entity, archetype, row and tag, 20 bytes, and its 12-byte vec3, read and written." },
         run: () => despawnObjects(),
     },
+    {
+        name: "despawn objects 10K string resource",
+        operation: "`despawn objects 10K` with the finalizer reading a string resource too, whose record the sync point's stop list holds a copy of, so the thread reads it as it was before apply.",
+        per: "despawns",
+        n: despawnedObjects,
+        typical: [1, 10_000],
+        best: { bytes: 56, basis: "As `despawn objects 10K`: the resource's copy is once per sync point." },
+        run: () => despawnObjects(spawnNoted, despawnNoted),
+    },
+    {
+        name: "despawn objects 10K linear resource",
+        operation: "`despawn objects 10K` with the finalizer reading a number and a vec3 resource too, which the sync point's stop list holds copies of, so the thread reads them as they were before apply.",
+        per: "despawns",
+        n: despawnedObjects,
+        typical: [1, 10_000],
+        best: { bytes: 56, basis: "As `despawn objects 10K`: the resources' copies are once per sync point." },
+        run: () => despawnObjects(spawnMeasured, despawnMeasured),
+    },
 ];

package/src/perftest/flat.ts

@@ -1,6 +1,6 @@
-import { Component } from "../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../interface/system/system.js";
-import { Archetype } from '../interface/archetype/archetype.js';
+import type { F32, U32 } from '../interface/math/index.js';
 
 // Mirrors adobe/data's ecs2 `create` perftest (packages/data/src/perftest/ecs2-perf.ts): 1M particles of eight scalar
 // components, interleaved over four archetypes by visible/enabled, each with its own values.
@@ -18,48 +18,38 @@ export const enabled = Symbol("flat/enabled");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [color]: { type: number };
-        [mass]: { type: number };
-        [positionX]: { type: number };
-        [positionY]: { type: number };
-        [positionZ]: { type: number };
-        [velocityX]: { type: number };
-        [velocityY]: { type: number };
-        [velocityZ]: { type: number };
+        [color]: { type: U32 };
+        [mass]: { type: F32 };
+        [positionX]: { type: F32 };
+        [positionY]: { type: F32 };
+        [positionZ]: { type: F32 };
+        [velocityX]: { type: F32 };
+        [velocityY]: { type: F32 };
+        [velocityZ]: { type: F32 };
         [visible]: { type: true };
         [enabled]: { type: true };
     }
 }
 
-Component.register(color, { type: { type: "integer", minimum: 0, maximum: 0xFFFFFFFF } });
-Component.register(mass, { type: { type: "number", precision: 1 } });
-Component.register(positionX, { type: { type: "number", precision: 1 } });
-Component.register(positionY, { type: { type: "number", precision: 1 } });
-Component.register(positionZ, { type: { type: "number", precision: 1 } });
-Component.register(velocityX, { type: { type: "number", precision: 1 } });
-Component.register(velocityY, { type: { type: "number", precision: 1 } });
-Component.register(velocityZ, { type: { type: "number", precision: 1 } });
-Component.register(visible, { type: { const: true } });
-Component.register(enabled, { type: { const: true } });
 
 const scalars = [color, mass, positionX, positionY, positionZ, velocityX, velocityY, velocityZ] as const;
 /** Entity i goes to archetype i % 4, like ecs2's seedSingle. */
 const archetypes = [
-    Archetype.create([...scalars, visible, enabled]),
-    Archetype.create([...scalars, visible]),
-    Archetype.create([...scalars, enabled]),
-    Archetype.create(scalars),
+    [...scalars, visible, enabled] as const,
+    [...scalars, visible] as const,
+    [...scalars, enabled] as const,
+    scalars,
 ] as const;
 
 /** Spawns with values passed inline. */
-export const spawnFlat = System.create({ name: "flat/spawn", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const spawnFlat = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) {
         commands.spawn(archetypes[i % 4])({ [color]: 0xff00ff, [mass]: 10, [positionX]: i + 1, [positionY]: i + 1, [positionZ]: i + 1, [velocityX]: -i, [velocityY]: -i, [velocityZ]: -i });
     }
 });
 
 /** The same spawns with each value object built first, as values from data or from another system's results are. */
-export const spawnFlatDynamic = System.create({ name: "flat/dynamic", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const spawnFlatDynamic = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (let i = 0; i < input.count; i++) {
         const values = { [color]: 0xff00ff, [mass]: 10, [positionX]: i + 1, [positionY]: i + 1, [positionZ]: i + 1, [velocityX]: -i, [velocityY]: -i, [velocityZ]: -i };
         commands.spawn(archetypes[i % 4])(values);

package/src/perftest/growth.ts

@@ -1,6 +1,6 @@
-import { Archetype } from "../interface/archetype/archetype.js";
-import { Component } from "../interface/component/component.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../interface/system/system.js";
+import type { F32 } from "../interface/math/index.js";
 
 // A hundred archetypes, each grown at once: what a sync point costs where every archetype it touches grows.
 
@@ -15,7 +15,7 @@ const g6 = Symbol("growth/g6");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [value]: { type: number };
+        [value]: { type: F32 };
         [g0]: { type: true };
         [g1]: { type: true };
         [g2]: { type: true };
@@ -26,30 +26,22 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(value, { type: { type: "number", precision: 1 } });
-Component.register(g0, { type: { const: true } });
-Component.register(g1, { type: { const: true } });
-Component.register(g2, { type: { const: true } });
-Component.register(g3, { type: { const: true } });
-Component.register(g4, { type: { const: true } });
-Component.register(g5, { type: { const: true } });
-Component.register(g6, { type: { const: true } });
 
 const tags = [g0, g1, g2, g3, g4, g5, g6] as const;
 /** `value` with each of the first 100 sets of the seven tags, by their bits. */
-const hundred = Array.from({ length: 100 }, (_, bits) => Archetype.create([value, ...tags.filter((_, bit) => (bits & (1 << bit)) !== 0)]));
+const hundred = Array.from({ length: 100 }, (_, bits) => [value, ...tags.filter((_, bit) => (bits & (1 << bit)) !== 0)] as const);
 
 /** Spawns `count` entities into each of the hundred archetypes. */
-export const fillEach = System.create({ name: "growth/fillEach", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+export const fillEach = System.create({}, ({ commands }, input: { readonly count: number }) => {
     for (const archetype of hundred) for (let i = 0; i < input.count; i++) commands.spawn(archetype)({ [value]: i });
 });
 
 /** One spawn into each of the hundred archetypes. */
-export const spawnEach = System.create({ name: "growth/spawnEach" }, ({ commands }) => {
+export const spawnEach = System.create({}, ({ commands }) => {
     for (const archetype of hundred) commands.spawn(archetype)({ [value]: 0 });
 });
 
 /** A kernel over every row of the hundred archetypes. */
-export const bumpEach = System.create({ name: "growth/bumpEach", kernel: "cpu", components: { write: [value] } }, row => {
+export const bumpEach = System.create({ kernel: true, components: { with: [value] } }, row => {
     row[value] = row[value] + 1;
 });

package/src/perftest/handoff.ts

@@ -1,12 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
-import { Resource } from "../interface/resource/resource.js";
 import { always } from "../interface/resources/always.js";
 import { eachTick } from "./observer.js";
 import { workers } from "../interface/resources/workers.js";
 import { System } from "../interface/system/system.js";
 import { backToBack, createWorld, type CreatedWorld } from "../implementation/index.js";
 import type { Benchmark } from "./benchmark.js";
-import { runReported } from "../implementation/world/reports.test-helper.js";
+import { runReported } from "../implementation/world/outcomes.test-helper.js";
 
 // Benchmarks of systems on a joined thread, which claims "handoffBenchmark": tiers handing off between the world's
 // thread and the joined one, and consecutive tiers on the joined one, which run as one task. Their systems reach their
@@ -22,33 +22,32 @@ declare module "@adobe/ecs" {
     }
 }
 /** An object of the joined thread, which places the systems reading it there. */
-Resource.register(token, { thread: "handoffBenchmark" });
 
-const here0 = System.create({ name: "handoff/here0" }, () => {});
-const there0 = System.create({ name: "handoff/there0", resources: { read: [token] }, after: [here0] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const here1 = System.create({ name: "handoff/here1", after: [there0] }, () => {});
-const there1 = System.create({ name: "handoff/there1", resources: { read: [token] }, after: [here1] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const here2 = System.create({ name: "handoff/here2", after: [there1] }, () => {});
-const there2 = System.create({ name: "handoff/there2", resources: { read: [token] }, after: [here2] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const here3 = System.create({ name: "handoff/here3", after: [there2] }, () => {});
-const there3 = System.create({ name: "handoff/there3", resources: { read: [token] }, after: [here3] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const here4 = System.create({ name: "handoff/here4", after: [there3] }, () => {});
-const there4 = System.create({ name: "handoff/there4", resources: { read: [token] }, after: [here4] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here0 = System.create({}, () => {});
+const there0 = System.create({ after: [here0] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here1 = System.create({ after: [there0] }, () => {});
+const there1 = System.create({ after: [here1] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here2 = System.create({ after: [there1] }, () => {});
+const there2 = System.create({ after: [here2] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here3 = System.create({ after: [there2] }, () => {});
+const there3 = System.create({ after: [here3] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const here4 = System.create({ after: [there3] }, () => {});
+const there4 = System.create({ after: [here4] }, ({ resources, commands }) => { void resources[token]; void commands; });
 /** Ten tiers alternating the world's thread and the joined one, empty systems. */
-export const handoff = System.create({ name: "handoff/ticks", systems: [here0, there0, here1, there1, here2, there2, here3, there3, here4, there4] });
+export const handoff = System.create({ systems: [here0, there0, here1, there1, here2, there2, here3, there3, here4, there4] });
 
-const fused0 = System.create({ name: "handoff/fused0", resources: { read: [token] } }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused1 = System.create({ name: "handoff/fused1", resources: { read: [token] }, after: [fused0] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused2 = System.create({ name: "handoff/fused2", resources: { read: [token] }, after: [fused1] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused3 = System.create({ name: "handoff/fused3", resources: { read: [token] }, after: [fused2] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused4 = System.create({ name: "handoff/fused4", resources: { read: [token] }, after: [fused3] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused5 = System.create({ name: "handoff/fused5", resources: { read: [token] }, after: [fused4] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused6 = System.create({ name: "handoff/fused6", resources: { read: [token] }, after: [fused5] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused7 = System.create({ name: "handoff/fused7", resources: { read: [token] }, after: [fused6] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused8 = System.create({ name: "handoff/fused8", resources: { read: [token] }, after: [fused7] }, ({ resources, commands }) => { void resources[token]; void commands; });
-const fused9 = System.create({ name: "handoff/fused9", resources: { read: [token] }, after: [fused8] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused0 = System.create({}, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused1 = System.create({ after: [fused0] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused2 = System.create({ after: [fused1] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused3 = System.create({ after: [fused2] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused4 = System.create({ after: [fused3] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused5 = System.create({ after: [fused4] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused6 = System.create({ after: [fused5] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused7 = System.create({ after: [fused6] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused8 = System.create({ after: [fused7] }, ({ resources, commands }) => { void resources[token]; void commands; });
+const fused9 = System.create({ after: [fused8] }, ({ resources, commands }) => { void resources[token]; void commands; });
 /** Ten consecutive tiers on the joined thread, empty systems. */
-export const fused = System.create({ name: "handoff/fused", systems: [fused0, fused1, fused2, fused3, fused4, fused5, fused6, fused7, fused8, fused9] });
+export const fused = System.create({ systems: [fused0, fused1, fused2, fused3, fused4, fused5, fused6, fused7, fused8, fused9] });
 
 /** Every system the joined thread runs, which it imports so the world can place them there. */
 export const handoffSystems: readonly System<void>[] = [handoff, fused];
@@ -65,9 +64,10 @@ const joinedFile = "./joined.js";
 const startClaiming = async (world: CreatedWorld): Promise<Joined> => {
     const message = (port: unknown) => ({ kind: "port", port, threads: ["handoffBenchmark"] });
     let joined: Joined;
+    let shared: Promise<void>;
     if (typeof globalThis.Worker === "function") {
         const { port1, port2 } = new MessageChannel();
-        world.share(port1);
+        shared = world.share(port1);
         const worker = new globalThis.Worker(new URL("./joined.js", import.meta.url), { type: "module" });
         await new Promise(resolve => {
             worker.onmessage = resolve;
@@ -78,7 +78,7 @@ const startClaiming = async (world: CreatedWorld): Promise<Joined> => {
     else {
         const threads = globalThis.process.getBuiltinModule("node:worker_threads");
         const { port1, port2 } = new threads.MessageChannel();
-        world.share(port1);
+        shared = world.share(port1);
         const worker = new threads.Worker(new URL(joinedFile, import.meta.url));
         await new Promise(resolve => {
             worker.once("message", resolve);
@@ -87,15 +87,7 @@ const startClaiming = async (world: CreatedWorld): Promise<Joined> => {
         joined = { terminate: async () => { await worker.terminate(); } };
     }
     // Its claims are active once it joined, so the systems run there from the first tick.
-    await new Promise<void>(resolve => {
-        let done = false;
-        const stop = world.threads(threads => {
-            if (done || threads.at(-1)?.status !== "joined") return;
-            done = true;
-            queueMicrotask(() => stop());
-            resolve();
-        });
-    });
+    await shared;
     return joined;
 };
 
@@ -125,8 +117,9 @@ const ticksBest = async (system: System<void>, stretches = 5): Promise<number> =
         if (report.failures.length > 0 || report.warnings.length === 0) throw new Error(`handoff: the joined thread didn't run its systems: ${report.failures[0]?.message ?? "none placed there"}.`);
     }
     finally {
-        await joined.terminate();
+        // Disposed first: ticks after the thread ended would fail its systems, reported out of band.
         await world.dispose();
+        await joined.terminate();
         driver.close();
     }
     return best;

package/src/perftest/hierarchy.ts

@@ -1,7 +1,7 @@
-import { Archetype } from "../interface/archetype/archetype.js";
-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";
 
 export const local = Symbol("hierarchy/local");
 export const world = Symbol("hierarchy/world");
@@ -17,40 +17,32 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(local, { type: { type: "number" } });
-Component.register(world, { type: { type: "number" } });
-Component.register(parent, { type: Entity.schema, reference: "owner" });
-Component.register(leaf, { type: { const: true } });
 
-const root = Archetype.create([local, world]);
-const child = Archetype.create([local, world, parent]);
-const taggedChild = Archetype.create([local, world, parent, leaf]);
+const root = [local, world] as const;
+const child = [local, world, parent] as const;
+const taggedChild = [local, world, parent, leaf] as const;
 
 /** Each row's world value is its parent's plus its own. */
 export const propagate = System.create({
-    name: "hierarchy/propagate",
-    kernel: "cpu",
-    components: { read: [local], write: [world] },
-    up: { through: parent, read: [world] },
+    kernel: true,
+    components: { with: [local, world] },
+    up: { through: parent },
 }, (row, { up }) => {
     row[world] = (up === null ? 0 : up[world]) + row[local];
 });
 
 /** The same, only for rows whose own or parent's values changed since it last ran. */
 export const propagateChanged = System.create({
-    name: "hierarchy/propagateChanged",
-    kernel: "cpu",
-    components: { read: [local], write: [world], changed: [local] },
-    up: { through: parent, read: [world] },
+    kernel: true,
+    components: { with: [local, world], changed: [local] },
+    up: { through: parent },
 }, (row, { up }) => {
     row[world] = (up === null ? 0 : up[world]) + row[local];
 });
 
 /** `roots` chains of `depth` rows each. */
 export const forest = System.create({
-    name: "hierarchy/forest",
-    input: { type: "object", properties: { roots: { type: "integer" }, depth: { type: "integer" } } },
-}, ({ input, commands }) => {
+}, ({ commands }, input: { readonly roots: number; readonly depth: number }) => {
     for (let r = 0; r < input.roots; r++) {
         let previous = commands.spawn(root)({ [local]: 1, [world]: 0 });
         for (let d = 1; d < input.depth; d++) previous = commands.spawn(child)({ [local]: 1, [world]: 0, [parent]: previous });
@@ -60,12 +52,12 @@ export const forest = System.create({
 const target = { type: "object", properties: { entity: Entity.schema } } as const;
 
 /** Changes one row's own value. */
-export const nudge = System.create({ name: "hierarchy/nudge", input: target, components: { write: [local] } }, (row, { input }) => {
+export const nudge = System.create({ kernel: false, components: { with: [local] } }, (row, _context, input: { readonly entity: Entity }) => {
     if (row.entity === input.entity) row[local] += 1;
 });
 
 /** Adds one leaf under a row. */
-export const sprout = System.create({ name: "hierarchy/sprout", input: target }, ({ input, commands }) => {
+export const sprout = System.create({}, ({ commands }, input: { readonly entity: Entity }) => {
     commands.spawn(child)({ [local]: 1, [world]: 0, [parent]: input.entity });
 });
 
@@ -75,9 +67,7 @@ const leaves: Entity[] = [];
 
 /** Despawns the leaves it spawned last time and spawns `count` new ones, one under each of `under`'s first rows; `tagged` puts them in an archetype of their own. */
 export const turnover = System.create({
-    name: "hierarchy/turnover",
-    input: { type: "object", properties: { count: { type: "integer" }, tagged: { type: "boolean" } } },
-}, ({ input, commands }) => {
+}, ({ commands }, input: { readonly count: number; readonly tagged: boolean }) => {
     for (const entity of leaves.splice(0)) commands.despawn(entity);
     for (let i = 0; i < input.count; i++) {
         leaves.push(input.tagged
@@ -88,9 +78,7 @@ export const turnover = System.create({
 
 /** Moves a row, and the subtree under it, to another parent. */
 export const reparent = System.create({
-    name: "hierarchy/reparent",
-    input: { type: "object", properties: { entity: Entity.schema, to: Entity.schema } },
-}, ({ input, commands }) => {
+}, ({ commands }, input: { readonly entity: Entity; readonly to: Entity }) => {
     commands.add(input.entity, parent, input.to);
 });
 
@@ -99,32 +87,27 @@ export const placed = Symbol("hierarchy/placed");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [offset]: { type: number };
-        [placed]: { type: number };
+        [offset]: { type: F32 };
+        [placed]: { type: F32 };
     }
 }
 
-Component.register(offset, { type: { type: "number", precision: 1 } });
-Component.register(placed, { type: { type: "number", precision: 1 } });
 
-const gpuRoot = Archetype.create([offset, placed]);
-const gpuChild = Archetype.create([offset, placed, parent]);
+const gpuRoot = [offset, placed] as const;
+const gpuChild = [offset, placed, parent] as const;
 
 /** `propagate` in 4-byte values, on the GPU. */
 export const place = System.create({
-    name: "hierarchy/place",
     kernel: "gpu",
-    components: { read: [offset], write: [placed] },
-    up: { through: parent, read: [placed] },
+    components: { with: [offset, placed] },
+    up: { through: parent },
 }, (row, { up }) => {
     row[placed] = (up === null ? 0 : up[placed]) + row[offset];
 });
 
 /** `forest` in 4-byte values. */
 export const gpuForest = System.create({
-    name: "hierarchy/gpuForest",
-    input: { type: "object", properties: { roots: { type: "integer" }, depth: { type: "integer" } } },
-}, ({ input, commands }) => {
+}, ({ commands }, input: { readonly roots: number; readonly depth: number }) => {
     for (let r = 0; r < input.roots; r++) {
         let previous = commands.spawn(gpuRoot)({ [offset]: 1, [placed]: 0 });
         for (let d = 1; d < input.depth; d++) previous = commands.spawn(gpuChild)({ [offset]: 1, [placed]: 0, [parent]: previous });