@adobe/ecs 0.1.0 → 0.2.0

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

@@ -1,5 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Entity } from "../../interface/entity/entity.js";
 import { Observe } from "../../observe/index.js";
 import { always } from "../../interface/resources/always.js";
@@ -23,9 +23,6 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(value, { type: { type: "number" } });
-Component.register(parent, { type: Entity.schema, reference: "owner" });
-Component.register(shared, { type: { type: "number" } });
 
 /** How many times each system's body was called. */
 const calls = { kept: 0, held: 0, alone: 0, other: 0, late: 0, self: 0, writer: 0, reader: 0 };
@@ -34,41 +31,41 @@ let current: World | null = null;
 /** What `selfRemoving` removes, once its body has been called this many times. */
 let removeAfter = Infinity;
 
-const seed = System.create({ name: "removeTest/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     const root = commands.spawn([value, shared])({ [value]: 0, [shared]: 0 });
     for (let i = 1; i < 10; i++) commands.spawn([value, parent, shared])({ [value]: i, [parent]: root, [shared]: 0 });
 });
 
 /** Run before tables are taken, so `value` and `parent` keep ticks then, as they do once any system filters on them. */
-const ticksValue = System.create({ name: "removeTest/ticksValue", components: { added: [value, parent] } }, () => {});
+const ticksValue = System.create({ components: { added: [value, parent] } }, () => {});
 
 /** Added for the whole of each test, so ticks go on. */
-const kept = System.create({ name: "removeTest/kept" }, () => { calls.kept++; });
+const kept = System.create({}, () => { calls.kept++; });
 
 /** Holds what systems can on the world's thread: an `up` order, a change filter's count, command buffers. */
-const held = System.create({ name: "removeTest/held", components: { read: [value], changed: [value] }, up: { through: parent, read: [value] } }, (row, { up }) => {
+const held = System.create({ components: { with: [value], changed: [value] }, up: { through: parent } }, (row, { up }) => {
     calls.held++;
     void (row[value] + (up?.[value] ?? 0));
 });
 
-const alone = System.create({ name: "removeTest/alone" }, () => { calls.alone++; });
-const other = System.create({ name: "removeTest/other" }, () => { calls.other++; });
-const pair = System.create({ name: "removeTest/pair", systems: [alone, other] });
+const alone = System.create({}, () => { calls.alone++; });
+const other = System.create({}, () => { calls.other++; });
+const pair = System.create({ systems: [alone, other] });
 
 /** In a later tier than `remover`, which removes it during the tick. */
-const late = System.create({ name: "removeTest/late", components: { read: [value] } }, row => { calls.late += row[value] >= 0 ? 1 : 0; });
-const remover = System.create({ name: "removeTest/remover", before: [late] }, () => { current?.remove(late); });
+const late = System.create({ components: { with: [value] } }, row => { calls.late += row[value] >= 0 ? 1 : 0; });
+const remover = System.create({ before: [late] }, () => { current?.remove(late); });
 
 /** Removes itself partway through its rows. */
-const selfRemoving = System.create({ name: "removeTest/selfRemoving", components: { read: [value] } }, row => {
+const selfRemoving = System.create({ components: { with: [value] } }, row => {
     calls.self += row[value] >= 0 ? 1 : 0;
     if (calls.self === removeAfter) current?.remove(selfRemoving);
 });
 
 /** Ordered only through `phase`: removing `phase` would leave them conflicting with no order between them. */
-const phase = System.create({ name: "removeTest/phase" }, () => {});
-const writer = System.create({ name: "removeTest/writer", components: { write: [shared] }, before: [phase] }, row => { calls.writer++; row[shared] += 1; });
-const reader = System.create({ name: "removeTest/reader", components: { read: [shared] }, after: [phase] }, row => { calls.reader++; void row[shared]; });
+const phase = System.create({}, () => {});
+const writer = System.create({ components: { with: [shared] }, before: [phase] }, row => { calls.writer++; row[shared] += 1; });
+const reader = System.create({ components: { with: [shared] }, after: [phase] }, row => { calls.reader++; void row[shared]; });
 
 /** A world ticking back to back once something is added, with `kept` added. */
 const ticking = async (): Promise<{ readonly world: CreatedWorld; readonly ticks: (count: number) => Promise<void>; readonly close: () => Promise<void> }> => {

package/src/implementation/world/render-order.browser.test.ts

@@ -0,0 +1,209 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import type { Entity } from "../../interface/entity/entity.js";
+import { Gpu } from "../../interface/gpu/gpu.js";
+import { Index } from "../../interface/indexes/index-type.js";
+import { gpuDevice } from "../../interface/resources/gpu-device.js";
+import { System } from "../../interface/system/system.js";
+import { createWorld } from "./create.js";
+import { runReported } from "./outcomes.test-helper.js";
+import type { F32, U32, Vec3 } from "../../interface/math/index.js";
+import { gpu } from "./gpu.test-helper.js";
+
+const depth = Symbol("renderOrderTest/depth");
+const code = Symbol("renderOrderTest/code");
+const shape = Symbol("renderOrderTest/shape");
+const image = Symbol("renderOrderTest/image");
+const size = Symbol("renderOrderTest/size");
+const visible = Symbol("renderOrderTest/visible");
+const hidden = Symbol("renderOrderTest/hidden");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [depth]: { type: F32 };
+        [code]: { type: U32 };
+        [shape]: { type: true };
+        [image]: { type: true };
+        [size]: { type: Vec3 };
+        [visible]: { type: true };
+        [hidden]: { type: true };
+    }
+}
+
+
+const byDepth = Index.create({ key: [depth], sorted: true });
+
+const device = async (): Promise<GPUDevice> => {
+    const adapter = await navigator.gpu.requestAdapter();
+    if (adapter === null) throw new Error("No WebGPU adapter.");
+    return adapter.requestDevice();
+};
+
+const count = 2000;
+const spawned: Entity[] = [];
+
+/**
+ * Shapes and images interleaved in depth, spawned in reverse depth order, so neither spawn nor row order is paint
+ * order. Every tenth is hidden or not visible, which the render system filters out, and plain depths match nothing.
+ */
+const spawn = System.create({}, ({ commands }) => {
+    for (let i = count - 1; i >= 0; i--) {
+        if (i % 10 === 3) spawned[i] = commands.spawn([depth, code, shape, visible, hidden])({ [depth]: i, [code]: i, [shape]: true, [visible]: true, [hidden]: true });
+        else if (i % 10 === 7) spawned[i] = commands.spawn([depth, code, image])({ [depth]: i, [code]: i, [image]: true });
+        else if (i % 2 === 0) spawned[i] = commands.spawn([depth, code, shape, visible])({ [depth]: i, [code]: i, [shape]: true, [visible]: true });
+        else spawned[i] = commands.spawn([depth, code, image, size, visible])({ [depth]: i, [code]: i, [image]: true, [size]: [i, i, i], [visible]: true });
+    }
+    commands.spawn([depth])({ [depth]: -1 });
+});
+
+/** The codes a frame should draw, in paint order. */
+const drawn = (codes: Iterable<number>): number[] => [...codes].filter(i => i % 10 !== 3 && i % 10 !== 7).sort((a, b) => a - b);
+
+describe("render systems with an order", () => {
+    it.runIf(gpu)("draw every matching archetype as one table, in the index's order, through the same accessors", async () => {
+        const own = await device();
+        const output = own.createBuffer({ size: (count + 16) * 8, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST });
+        const tableCounts: number[][] = [];
+        const draw = System.render({
+            components: { with: [visible], not: [hidden] },
+            order: byDepth,
+            shader: { accessors: { paintDepth: depth, paintCode: code } },
+        }, ({ encoder, tables }) => {
+            tableCounts.push(tables.map(table => table.count));
+            encoder.clearBuffer(output);
+            const pass = encoder.beginComputePass();
+            pass.setPipeline(pipeline);
+            pass.setBindGroup(1, outputGroup);
+            for (const table of tables) {
+                table.bind(pass);
+                pass.dispatchWorkgroups(Math.ceil(table.count / 64));
+            }
+            pass.end();
+        });
+        const outputLayout = own.createBindGroupLayout({ entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } }] });
+        const outputGroup = own.createBindGroup({ layout: outputLayout, entries: [{ binding: 0, resource: { buffer: output } }] });
+        const module = own.createShaderModule({
+            code: `${Gpu.wgsl(draw)}
+@group(1) @binding(0) var<storage, read_write> output: array<vec2u>;
+@compute @workgroup_size(64) fn main(@builtin(global_invocation_id) id: vec3u) {
+    if (id.x >= ecs_count()) { return; }
+    output[id.x] = vec2u(u32(paintDepth(id.x)), paintCode(id.x));
+}`,
+        });
+        expect((await module.getCompilationInfo()).messages.filter(message => message.type === "error")).toEqual([]);
+        const pipeline = own.createComputePipeline({ layout: own.createPipelineLayout({ bindGroupLayouts: [Gpu.layout(own), outputLayout] }), compute: { module, entryPoint: "main" } });
+
+        /** What the last frame drew: depth and code per instance. */
+        const read = async (): Promise<number[][]> => {
+            const staging = own.createBuffer({ size: output.size, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+            const encoder = own.createCommandEncoder();
+            encoder.copyBufferToBuffer(output, 0, staging, 0, output.size);
+            own.queue.submit([encoder.finish()]);
+            await staging.mapAsync(GPUMapMode.READ);
+            const words = new Uint32Array(staging.getMappedRange().slice(0));
+            staging.destroy();
+            const instances = tableCounts.at(-1)?.[0] ?? 0;
+            return Array.from({ length: instances }, (_, i) => [words[2 * i], words[2 * i + 1]]);
+        };
+        const frame = async (): Promise<void> => expect((await runReported(world, draw)).failures).toEqual([]);
+
+        const world = createWorld({ [gpuDevice]: own });
+        await world.run(spawn);
+        await frame();
+        const codes = new Set(Array.from({ length: count }, (_, i) => i));
+        let expected = drawn(codes);
+        expect(tableCounts.at(-1)).toEqual([expected.length]);
+        expect(await read()).toEqual(expected.map(i => [i, i]));
+
+        // A despawn moves another shape into its row, a spawn adds an image between two others, and a key moves a shape
+        // to the back; a frame after each draws the new order.
+        const despawn = System.create({}, ({ commands }) => commands.despawn(spawned[count - 2]));
+        await world.run(despawn);
+        codes.delete(count - 2);
+        await frame();
+        expected = drawn(codes);
+        expect(await read()).toEqual(expected.map(i => [i, i]));
+
+        const addImage = System.create({}, ({ commands }) => {
+            commands.spawn([depth, code, image, size, visible])({ [depth]: 500.5, [code]: 5001, [image]: true, [size]: [0, 0, 0], [visible]: true });
+        });
+        await world.run(addImage);
+        await frame();
+        const withImage = expected.flatMap(i => i === 500 ? [[i, i], [500, 5001]] : [[i, i]]);
+        expect(await read()).toEqual(withImage);
+
+        const toBack = System.create({ components: { with: [code, depth] } }, row => {
+            if (row[code] === 10) row[depth] = count + 5;
+        });
+        await world.run(toBack);
+        await frame();
+        const atBack = [...withImage.filter(([, c]) => c !== 10), [count + 5, 10]];
+        expect(await read()).toEqual(atBack);
+
+        // Showing a hidden shape adds it to the one table, in its place.
+        const show = System.create({}, ({ commands }) => commands.remove(spawned[13], hidden));
+        await world.run(show);
+        await frame();
+        const shown = atBack.flatMap(([d, c]) => d === 12 ? [[d, c], [13, 13]] : [[d, c]]);
+        expect(await read()).toEqual(shown);
+        expect(tableCounts.every(counts => counts.length === 1)).toBe(true);
+        await world.dispose();
+    });
+
+    it.runIf(gpu)("write their order only when the index's entries change or move", async () => {
+        const own = await device();
+        const draw = System.render({ components: { with: [visible], not: [hidden] }, order: byDepth, shader: { accessors: { paintDepth: depth } } }, () => {});
+        const world = createWorld({ [gpuDevice]: own });
+        await world.run(spawn);
+        await world.run(draw);
+        const instances = drawn(Array.from({ length: count }, (_, i) => i)).length;
+        // Row uploads and block writes pass a size; record writes don't.
+        const sizes: number[] = [];
+        const { queue } = own;
+        const write = queue.writeBuffer.bind(queue);
+        let records = 0;
+        queue.writeBuffer = (buffer, offset, data, dataOffset, size) => {
+            if (size === undefined) records++;
+            else sizes.push(size);
+            write(buffer, offset, data, dataOffset, size);
+        };
+        await world.run(draw);
+        expect([sizes, records]).toEqual([[], 0]);
+        // A new key writes its chunk of the column and the order, in elements; the record stays.
+        const toBack = System.create({ components: { with: [code, depth] } }, row => {
+            if (row[code] === 10) row[depth] = count + 5;
+        });
+        await world.run(toBack);
+        await world.run(draw);
+        expect(sizes.slice(1)).toEqual([instances]);
+        expect(records).toBe(0);
+        sizes.length = 0;
+        await world.run(draw);
+        expect(sizes).toEqual([]);
+        await world.dispose();
+    });
+
+    it.runIf(gpu)("give a shader one table when nothing matches", async () => {
+        const own = await device();
+        let tables: readonly System.RenderTable[] = [];
+        const draw = System.render({ components: { with: [hidden, image] }, order: byDepth, shader: { accessors: { paintDepth: depth } } }, context => { tables = context.tables; });
+        const world = createWorld({ [gpuDevice]: own });
+        await world.run(spawn);
+        expect((await runReported(world, draw)).failures).toEqual([]);
+        expect(tables.map(table => table.count)).toEqual([0]);
+        await world.dispose();
+    });
+
+    it.runIf(gpu)("declare their ordered accessors, which compile", async () => {
+        const own = await device();
+        const draw = System.render({ order: byDepth, shader: { group: 2, accessors: { paintDepth: depth, paintSize: size } } }, () => {});
+        const code = Gpu.wgsl(draw);
+        expect(code).toContain("fn paintDepth(row: u32) -> f32");
+        expect(code).toContain("fn paintSize(row: u32) -> vec3<f32>");
+        expect(code).toContain("@group(2) @binding(1) var<uniform> ecs_table: EcsTable;");
+        // An instance is its position in the order, which the order block maps to a table and a row.
+        expect(code).toContain("struct EcsTable { ecs_rows: u32, ecs_order: u32, ecs_tables: u32, ecs_shift: u32 }");
+        const module = own.createShaderModule({ code: `${code}\n@compute @workgroup_size(1) fn main() { _ = paintDepth(0u); _ = paintSize(0u); _ = ecs_count(); }` });
+        expect((await module.getCompilationInfo()).messages.filter(message => message.type === "error")).toEqual([]);
+    });
+});

package/src/implementation/world/render-order.ts

@@ -0,0 +1,150 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { RenderContext, RenderTable } from '../../interface/system/render.js';
+import type { Archetype } from './archetype.js';
+import type { GpuEngine } from './gpu.js';
+import type { Ordered } from './index-order.js';
+import { blockBase } from './index-sorted.js';
+import type { WorldIndex } from './indexes.js';
+
+// A render system with `order` draws one table: instance `i` is the i-th matching entity in its sorted index's order.
+// Its record is the instance count, the word addresses of its order block and tables block, and the bits a slot is
+// shifted by. The order block holds, by position, a matched archetype's slot above `shift` bits and its row below
+// them; the tables block holds, by slot, the word address of each accessor's column. The order block is built and
+// written only when the index's entries changed or moved, or the matches grew; the tables block only when a column's
+// address changed; the record only when one of its words did.
+
+/** The table of a render system's run and its context, both reused. */
+type MutableTable = { count: number; bind: (pass: GPURenderPassEncoder | GPUComputePassEncoder) => void };
+type MutableContext = { device: GPUDevice; encoder: GPUCommandEncoder; tables: readonly RenderTable[] };
+
+export type OrderedRender = {
+    /**
+     * Uploads what the run's one table reads; returns null, or the reason it can't be drawn: more matched archetypes
+     * and rows than an entry's 32 bits hold.
+     */
+    readonly prepare: (gpu: GpuEngine, matches: readonly Archetype[], tick: number) => string | null;
+    /** The body's context, once the work recorded before it is submitted. */
+    readonly context: (gpu: GpuEngine) => RenderContext;
+};
+
+/**
+ * `columns` are the accessors' component ids, in accessor order; `group` the bind group the shader declares; `key`
+ * the prefix of the runner's GPU records.
+ */
+export const createOrderedRender = (index: WorldIndex, ordered: Ordered, columns: readonly number[], group: number, key: string): OrderedRender => {
+    const width = columns.length;
+    const orderKey = `${key}order`;
+    const tablesKey = `${key}tables`;
+    const recordKey = `${key}ordered`;
+    let entries = new Int32Array(64);
+    let instances = 0;
+    let tables = new Int32Array(Math.max(1, width));
+    /** What the order block was last built from: the index's ticks, the matches, and the GPU it was written to. */
+    let builtChanged = -1;
+    let builtMoved = -1;
+    let builtMatches = -1;
+    let builtGpu: GpuEngine | null = null;
+    let shift = 31;
+    const words = new Uint32Array(4);
+    let recorded = false;
+    const offsets = [0];
+    let bound: GpuEngine | null = null;
+    const table: MutableTable = {
+        count: 0,
+        bind: pass => {
+            if (bound !== null) pass.setBindGroup(group, bound.renderGroup(), offsets);
+        },
+    };
+    const list: readonly RenderTable[] = [table];
+    let context: MutableContext | null = null;
+
+    /** Lists the index's entries of matched archetypes, in its order, as slot and row. */
+    const build = (matches: readonly Archetype[]): void => {
+        const sorted = index.sorted;
+        instances = 0;
+        if (sorted === null) return;
+        if (entries.length < sorted.size) entries = new Int32Array(Math.max(sorted.size, 2 * entries.length));
+        const owners = ordered.owners(matches);
+        const known = owners.length;
+        const slotShift = shift;
+        const { order, lengths, stride, words: keyWords, blocks } = sorted;
+        const sortedEntries = sorted.entries;
+        for (let k = 0; k < blocks; k++) {
+            const block = order[k];
+            const base = blockBase(sorted, block) + keyWords;
+            for (let at = base, end = base + lengths[block] * stride; at < end; at += stride) {
+                const archetype = sortedEntries[at + 1];
+                const owner = archetype < known ? owners[archetype] : -1;
+                if (owner < 0) continue;
+                entries[instances++] = (owner << slotShift) | sortedEntries[at + 2];
+            }
+        }
+    };
+
+    const prepare = (gpu: GpuEngine, matches: readonly Archetype[], tick: number): string | null => {
+        const slots = matches.length;
+        if (gpu !== builtGpu) {
+            builtGpu = gpu;
+            builtChanged = -1;
+            recorded = false;
+        }
+        // The tables block: every column's address, uploading rows the CPU changed first.
+        if (tables.length < slots * width) {
+            const grown = new Int32Array(Math.max(slots * width, 2 * tables.length));
+            grown.set(tables);
+            tables = grown;
+        }
+        let addressed = false;
+        let most = 0;
+        for (let slot = 0; slot < slots; slot++) {
+            const archetype = matches[slot];
+            const { count } = archetype;
+            if (count > most) most = count;
+            for (let k = 0; k < width; k++) {
+                const storage = count === 0 ? undefined : archetype.storageById[columns[k]];
+                const address = storage === undefined ? 0 : gpu.upload(archetype, storage, tick);
+                const at = slot * width + k;
+                if (tables[at] !== address) {
+                    tables[at] = address;
+                    addressed = true;
+                }
+            }
+        }
+        if (slots !== builtMatches) {
+            // At least one bit of slot, so a row's mask is never 32 bits.
+            const slotBits = Math.max(1, Math.ceil(Math.log2(slots)));
+            shift = 32 - slotBits;
+            builtMatches = slots;
+            builtChanged = -1;
+        }
+        if (most > 2 ** shift) return `with ${slots} matching archetypes an ordered table names at most ${2 ** shift} rows of each, and one holds ${most}`;
+        const rebuilt = index.changed !== builtChanged || index.moved !== builtMoved;
+        if (rebuilt) {
+            build(matches);
+            builtChanged = index.changed;
+            builtMoved = index.moved;
+        }
+        const orderAddress = gpu.uploadIndexes(orderKey, entries, instances, rebuilt);
+        const tablesAddress = gpu.uploadIndexes(tablesKey, tables, slots * width, addressed);
+        if (!recorded || words[0] !== instances || words[1] !== orderAddress || words[2] !== tablesAddress || words[3] !== shift) {
+            words[0] = instances;
+            words[1] = orderAddress;
+            words[2] = tablesAddress;
+            words[3] = shift;
+            offsets[0] = gpu.record(recordKey, words);
+            recorded = true;
+        }
+        bound = gpu;
+        table.count = instances;
+        return null;
+    };
+
+    const contextOf = (gpu: GpuEngine): RenderContext => {
+        if (context === null) return context = { device: gpu.device, encoder: gpu.encoder(), tables: list };
+        context.device = gpu.device;
+        context.encoder = gpu.encoder();
+        return context;
+    };
+
+    return { prepare, context: contextOf };
+};

package/src/implementation/world/required.ts

@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ComponentLists } from '../../interface/system/access.js';
+
+/** The components every entity a system's lists match has: what it reads, writes, has and filters on, but its optional ones. */
+export const requiredOf = (lists: ComponentLists | undefined): readonly symbol[] => {
+    if (lists === undefined) return [];
+    const { optional } = lists;
+    const all = new Set([...lists.read ?? [], ...lists.write ?? [], ...lists.has ?? [], ...lists.added ?? [], ...lists.changed ?? []]);
+    return optional === undefined ? [...all] : [...all].filter(key => !optional.includes(key));
+};

package/src/implementation/world/resources.ts

@@ -1,6 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Storage } from './archetype.js';
 import { indexOf, reserve } from './entities.js';
-import { defaultOf, idOf, type Key, type State } from './state.js';
+import { idOf, type Key, type State } from './state.js';
 import { synchronizeAlone } from './synchronize.js';
 import { addCommand, createBuffer, spawnCommand } from './buffer.js';
 import { pushValues } from './commands.js';
@@ -9,8 +10,11 @@ import { labelOf } from '../../interface/registry/index.js';
 /** Resources are components on one entity, so they share storage, ticks and sync with every other component. */
 export type ResourceCell = { readonly storage: Storage; readonly row: number };
 
-/** A resource's value before anything writes it: the one given at the world's creation, or its default. */
-export const initialOf = (state: State, key: Key): unknown => state.initial.has(key) ? state.initial.get(key) : defaultOf(key);
+/**
+ * A resource's value before anything writes it: the one given at the world's creation, or the start the world made
+ * for it, so a fresh `Map` or `Set` is one value however often it's read.
+ */
+export const initialOf = (state: State, key: Key): unknown => state.initial.has(key) ? state.initial.get(key) : state.starts[idOf(state, key)];
 
 /**
  * Adds any missing resources with their initial values, as their own sync point, between runs; commands that are

package/src/implementation/world/rows.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 type { Entity } from "../../interface/entity/entity.js";
 import type { Schema } from "../../interface/schema/schema.js";
 import { System } from "../../interface/system/system.js";
 import { readEach, select } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
 import { workers } from "../../interface/resources/workers.js";
+import type { U32 } from "../../interface/math/index.js";
 
 type Vec3 = readonly [number, number, number];
 const vec3 = { type: "array", items: { type: "number", precision: 1 }, minItems: 3, maxItems: 3 } as const satisfies Schema;
@@ -16,19 +17,15 @@ const tag = Symbol("rowsTest/tag");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [position]: { type: readonly [number, number, number] };
-        [count]: { type: number };
+        [position]: { type: Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }> };
+        [count]: { type: U32 };
         [flag]: { type: boolean };
         [tag]: { type: true };
     }
 }
 
-Component.register(position, { type: vec3 });
-Component.register(count, { type: { type: "integer", minimum: 0, maximum: 1000 } });
-Component.register(flag, { type: { type: "boolean" } });
-Component.register(tag, { type: { const: true } });
 
-const seed = System.create({ name: "rowsTest/seed" }, ({ commands }) => {
+const seed = System.create({}, ({ commands }) => {
     for (let i = 0; i < 4; i++) commands.spawn(i < 2 ? [position, count, flag, tag] : [position, count, flag])({ [position]: [i, i + 0.5, -i], [count]: i, [flag]: i % 2 === 0 });
 });
 
@@ -37,17 +34,17 @@ describe("accessor rows", () => {
         const seen: { entity: Entity; position: Vec3; count: number; flag: boolean }[] = [];
         const kept: Vec3[] = [];
         // Both run over two archetypes (with and without the tag), with a system using a different row between them.
-        const first = System.create({ name: "rowsTest/first", components: { read: [position, flag], write: [count] } }, row => {
+        const first = System.create({ components: { with: [position, flag, count] } }, row => {
             const value = row[position];
             kept.push(value);
             seen.push({ entity: row.entity, position: value, count: row[count], flag: row[flag] });
             row[count] = row[count] + 10;
         });
-        const other = System.create({ name: "rowsTest/other", components: { write: [position] }, after: [first] }, row => {
+        const other = System.create({ components: { with: [position] }, after: [first] }, row => {
             const [x, y, z] = row[position];
             row[position] = [x + 100, y, z];
         });
-        const second = System.create({ name: "rowsTest/second", components: { read: [position, flag], write: [count] }, after: [other] }, row => {
+        const second = System.create({ components: { with: [position, flag, count] }, after: [other] }, row => {
             seen.push({ entity: row.entity, position: row[position], count: row[count], flag: row[flag] });
             row[count] = row[count] + 1;
         });