@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/unidentified-finalizers.test.ts

@@ -0,0 +1,58 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import { Finalizer, System, workers } from "../../index.js";
+import { createWorld, join } from "./create.js";
+import { runReported } from "./outcomes.test-helper.js";
+
+const held = Symbol("unidentifiedFinalizers/held");
+declare module "@adobe/ecs" {
+    interface Threads { unidentifiedFinalizers: true }
+    interface Components { [held]: { type: { readonly text: string } | null; thread: "unidentifiedFinalizers" } }
+}
+
+const nothing = System.create(() => {});
+const spawn = System.create(({ commands }) => { commands.spawn([held])({ [held]: null }); });
+const seen: unknown[] = [];
+/** A finalizer reading the thread's objects, made where the build gives it no id. */
+const unidentified = (): void => { Finalizer.create({ components: { with: [held] } }, row => { seen.push(row[held]); }); };
+
+/** `"joined"` once a share or join resolved, or the message it rejected with. */
+const outcomeOf = (promise: Promise<unknown>): Promise<string> => promise.then(() => "joined", (error: unknown) => error instanceof Error ? error.message : String(error));
+
+/** A world shared with a thread on this one claiming the thread: what its share and its join gave, and the joined world. */
+const shared = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const channel = new MessageChannel();
+    const sharing = outcomeOf(world.share(channel.port1));
+    const joining = join(channel.port2, { threads: ["unidentifiedFinalizers"] });
+    const joined = await outcomeOf(joining);
+    const remote = joined === "joined" ? await joining : null;
+    return { world, remote, shared: await sharing, joined };
+};
+
+describe("a finalizer without an id on a thread a joined thread fills", () => {
+    // Created after the claim, so the claim is made; the next run reports it once and the world goes on without it.
+    it("fails once, in a report, and leaves the world running", async () => {
+        const { world, remote, shared: share } = await shared();
+        expect(share).toBe("joined");
+        if (remote === null) throw new Error("The thread didn't join.");
+        await remote.run(spawn);
+        unidentified();
+        const first = await runReported(world, nothing);
+        expect(first.failures.map(failure => [failure.kind, failure.message.includes("has no id")])).toEqual([["finalizer", true]]);
+        expect((await runReported(world, nothing)).failures).toEqual([]);
+        await remote.run(nothing);
+        await world.dispose();
+    }, 10_000);
+
+    // Finalizers are program-wide, so the one the test above made is present when this thread claims: the claim is
+    // refused, and both the world's share and the thread's join say why.
+    it("refuses a later claim of its thread, rejecting its share and its join, saying why", async () => {
+        const { world, remote, shared: share, joined } = await shared();
+        expect(share).toMatch(/has no id, so a joined thread can't run it/);
+        expect(joined).toBe(share);
+        expect(remote).toBeNull();
+        await world.run(nothing);
+        await world.dispose();
+    }, 10_000);
+});

package/src/implementation/world/up-tree.test.ts

@@ -1,10 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Entity } from "../../interface/entity/entity.js";
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
 import { readEach, select } from "./reads.test-helper.js";
-import { createWorld } from "./create.js";
+import { createWorld, type CreatedWorld } from "./create.js";
 import { workers } from "../../interface/resources/workers.js";
 
 const local = Symbol("upTreeTest/local");
@@ -12,6 +12,8 @@ const full = Symbol("upTreeTest/full");
 const filtered = Symbol("upTreeTest/filtered");
 const parent = Symbol("upTreeTest/parent");
 const hidden = Symbol("upTreeTest/hidden");
+const free = Symbol("upTreeTest/free");
+const marked = Symbol("upTreeTest/marked");
 
 declare module "@adobe/ecs" {
     interface Components {
@@ -20,44 +22,49 @@ declare module "@adobe/ecs" {
         [filtered]: { type: number };
         [parent]: { type: Entity; reference: "weak" };
         [hidden]: { type: true };
+        [free]: { type: number };
+        [marked]: { type: true };
     }
 }
 
-Component.register(local, { type: { type: "number" } });
-Component.register(full, { type: { type: "number" } });
-Component.register(filtered, { type: { type: "number" } });
-Component.register(parent, { type: Entity.schema, reference: "weak" });
-Component.register(hidden, { type: { const: true } });
 
 const propagateFull = System.create({
-    name: "upTreeTest/propagateFull",
-    kernel: "cpu",
-    components: { read: [local], write: [full], not: [hidden] },
-    up: { through: parent, read: [full] },
+    kernel: true,
+    components: { with: [local, full], not: [hidden] },
+    up: { through: parent },
 }, (row, { up }) => {
     row[full] = (up === null ? 0 : up[full]) + row[local];
 });
 const propagateFiltered = System.create({
-    name: "upTreeTest/propagateFiltered",
-    kernel: "cpu",
-    components: { read: [local], write: [filtered], changed: [local], not: [hidden] },
-    up: { through: parent, read: [filtered] },
+    kernel: true,
+    components: { with: [local, filtered], changed: [local], not: [hidden] },
+    up: { through: parent },
 }, (row, { up }) => {
     row[filtered] = (up === null ? 0 : up[filtered]) + row[local];
 });
 
+/** As `propagateFiltered`, into `free`, over rows without `marked`: it agrees with the others until a marked row exists. */
+const propagateUnmarked = System.create({
+    kernel: true,
+    components: { with: [local, free], changed: [local], not: [hidden, marked] },
+    up: { through: parent },
+}, (row, { up }) => {
+    row[free] = (up === null ? 0 : up[free]) + row[local];
+});
+
 type Operation =
     | { readonly kind: "spawn"; readonly local: number; readonly parent: Entity | null }
     | { readonly kind: "despawn" | "hide" | "show" | "orphan"; readonly entity: Entity }
     | { readonly kind: "reparent"; readonly entity: Entity; readonly to: Entity }
-    | { readonly kind: "set"; readonly entity: Entity; readonly local: number };
+    | { readonly kind: "set"; readonly entity: Entity; readonly local: number }
+    | { readonly kind: "mark"; readonly entity: Entity };
 const operations: Operation[] = [];
-const apply = System.create({ name: "upTreeTest/apply" }, ({ commands }) => {
+const apply = System.create({}, ({ commands }) => {
     for (const operation of operations.splice(0)) {
         switch (operation.kind) {
             case "spawn":
-                if (operation.parent === null) commands.spawn([local, full, filtered])({ [local]: operation.local, [full]: 0, [filtered]: 0 });
-                else commands.spawn([local, full, filtered, parent])({ [local]: operation.local, [full]: 0, [filtered]: 0, [parent]: operation.parent });
+                if (operation.parent === null) commands.spawn([local, full, filtered, free])({ [local]: operation.local, [full]: 0, [filtered]: 0, [free]: 0 });
+                else commands.spawn([local, full, filtered, free, parent])({ [local]: operation.local, [full]: 0, [filtered]: 0, [free]: 0, [parent]: operation.parent });
                 break;
             case "despawn": commands.despawn(operation.entity); break;
             case "hide": commands.add(operation.entity, hidden, true); break;
@@ -65,6 +72,7 @@ const apply = System.create({ name: "upTreeTest/apply" }, ({ commands }) => {
             case "orphan": commands.remove(operation.entity, parent); break;
             case "reparent": commands.add(operation.entity, parent, operation.to); break;
             case "set": commands.add(operation.entity, local, operation.local); break;
+            case "mark": commands.add(operation.entity, marked, true); break;
         }
     }
 });
@@ -80,10 +88,11 @@ const generator = (seed: number) => {
 };
 
 /** What each matched row outside a cycle should hold, from the world's current tree and the values it stores. */
-const expected = async (ecs: World, key: typeof full | typeof filtered): Promise<Map<Entity, number>> => {
+const expected = async (ecs: World, key: typeof full | typeof filtered | typeof free): Promise<Map<Entity, number>> => {
     const entities = await select(ecs, { required: [local] });
     const alive = new Set(entities);
     const isHidden = new Set(await select(ecs, { required: [hidden] }));
+    if (key === free) for (const entity of await select(ecs, { required: [marked] })) isHidden.add(entity);
     // The walk reads only live entities, so one read of each component up front serves it.
     const byEntity = <T>(values: readonly T[]): Map<Entity, T> => new Map(entities.map((entity, i) => [entity, values[i]]));
     const parents = byEntity(await readEach(ecs, entities, parent));
@@ -117,7 +126,7 @@ const expected = async (ecs: World, key: typeof full | typeof filtered): Promise
     return result;
 };
 
-const actual = async (ecs: World, key: typeof full | typeof filtered, rows: Iterable<Entity>): Promise<Map<Entity, number>> => {
+const actual = async (ecs: World, key: typeof full | typeof filtered | typeof free, rows: Iterable<Entity>): Promise<Map<Entity, number>> => {
     const entities = [...rows];
     const values = await readEach(ecs, entities, key);
     return new Map(entities.map((entity, i) => [entity, values[i] ?? 0]));
@@ -150,3 +159,154 @@ it.each([true, false])("keeps its tree current across spawns, despawns, reparent
         }
     }
 });
+
+it.each([true, false])("keeps a tree `up`s share current while one runs less often and one stops agreeing on what matches, with WASM %s", async wasm => {
+    await using ecs = createWorld({ [workers]: 0 }, { wasm });
+    const random = generator(11);
+    for (let k = 0; k < 30; k++) operations.push({ kind: "spawn", local: random(10), parent: null });
+    await ecs.run(apply);
+    for (let frame = 0; frame < 200; frame++) {
+        const entities = await select(ecs, { required: [local] });
+        const any = (): Entity => entities[random(entities.length)];
+        for (let k = 0; k < 4; k++) {
+            switch (random(8)) {
+                case 0: operations.push({ kind: "spawn", local: random(10), parent: random(4) === 0 ? null : any() }); break;
+                case 1: if (entities.length > 20) operations.push({ kind: "despawn", entity: any() }); break;
+                case 2: operations.push({ kind: random(2) === 0 ? "hide" : "show", entity: any() }); break;
+                case 3: operations.push({ kind: "orphan", entity: any() }); break;
+                case 4: case 5: operations.push({ kind: "reparent", entity: any(), to: any() }); break;
+                default: operations.push({ kind: "set", entity: any(), local: random(10) });
+            }
+        }
+        // From here on, a marked archetype matches all but `propagateUnmarked`, which then keeps a tree of its own.
+        if (frame >= 100 && random(4) === 0) operations.push({ kind: "mark", entity: any() });
+        await ecs.run(apply);
+        await ecs.run(propagateFull);
+        if (frame % 7 === 0) await ecs.run(propagateFiltered);
+        await ecs.run(propagateUnmarked);
+        const checked = frame % 7 === 0 ? [full, filtered, free] as const : [full, free] as const;
+        for (const key of checked) {
+            const want = await expected(ecs, key);
+            expect(await actual(ecs, key, want.keys()), `${String(key)}, frame ${frame}`).toEqual(want);
+        }
+    }
+});
+
+it("keeps a filtered `up` right that runs less often than its tree's other readers, across rebuilds", async () => {
+    await using ecs = createWorld({ [workers]: 0 });
+    for (let k = 0; k < 2_000; k++) operations.push({ kind: "spawn", local: 1 + k % 10, parent: null });
+    await ecs.run(apply);
+    const parents = await select(ecs, { required: [local] });
+    for (const entity of parents) operations.push({ kind: "spawn", local: 1, parent: entity });
+    await ecs.run(apply);
+    await ecs.run(propagateFull);
+    await ecs.run(propagateFiltered);
+    // Hiding and showing every parent changes no child's own values: only the tree tells the filtered `up` they changed.
+    // A few hundred a frame, so the tree builds again only every few frames, between the filtered `up`'s runs.
+    for (let frame = 0; frame < 24; frame++) {
+        for (const entity of parents.slice((frame >> 1) % 4 * 500, ((frame >> 1) % 4 + 1) * 500)) operations.push({ kind: frame % 2 === 0 ? "hide" : "show", entity });
+        await ecs.run(apply);
+        await ecs.run(propagateFull);
+    }
+    await ecs.run(propagateFiltered);
+    for (const key of [full, filtered] as const) {
+        const want = await expected(ecs, key);
+        expect(await actual(ecs, key, want.keys()), String(key)).toEqual(want);
+    }
+});
+
+let ranRows = 0;
+/** As `propagateFiltered`, in JS, counting the rows it runs. */
+const countFiltered = System.create({
+    kernel: false,
+    components: { with: [local, filtered], changed: [local], not: [hidden] },
+    up: { through: parent },
+}, (row, { up }) => {
+    ranRows++;
+    row[filtered] = (up === null ? 0 : up[filtered]) + row[local];
+});
+
+it("runs only the rows a filtered `up` needs while the journal holds what changed since its last run", async () => {
+    await using ecs = createWorld({ [workers]: 0 });
+    for (let k = 0; k < 4_000; k++) operations.push({ kind: "spawn", local: k % 10, parent: null });
+    await ecs.run(apply);
+    await ecs.run(countFiltered);
+    const entities = await select(ecs, { required: [local] });
+    const ran: number[] = [];
+    for (let frame = 0; frame < 24; frame++) {
+        // 250 a frame, a sixteenth of the journal: those shown again, and one set, pass.
+        for (const entity of entities.slice((frame >> 1) % 8 * 250, ((frame >> 1) % 8 + 1) * 250)) operations.push({ kind: frame % 2 === 0 ? "hide" : "show", entity });
+        operations.push({ kind: "set", entity: entities[3_999], local: frame });
+        await ecs.run(apply);
+        ranRows = 0;
+        await ecs.run(countFiltered);
+        ran.push(ranRows);
+    }
+    expect(ran.filter(rows => rows > 251)).toEqual([]);
+    const want = await expected(ecs, filtered);
+    expect(await actual(ecs, filtered, want.keys())).toEqual(want);
+});
+
+const camera = Symbol("upTreeTest/camera");
+declare module "@adobe/ecs" {
+    interface Resources {
+        [camera]: { type: number; default: 0 };
+    }
+}
+/** A filtered `up` every run of which is a whole pass, since the resource it filters on changes every frame. */
+const layoutEveryFrame = System.create({
+    kernel: false,
+    components: { with: [local, filtered], changed: [local] },
+    resources: { changed: [camera] },
+    up: { through: parent },
+}, (row, { up }) => {
+    row[filtered] = (up === null ? 0 : up[filtered]) + row[local];
+});
+const moveCamera = System.create({}, ({ resources }) => {
+    resources[camera] += 1;
+});
+
+/** Reparents `count` random entities under the first ten, `frames` times, running `each` after each, and gives the most `up`s held. */
+const mostTouched = async (ecs: CreatedWorld, frames: number, count: number, each: () => Promise<unknown>): Promise<number> => {
+    const entities = await select(ecs, { required: [local] });
+    const random = generator(5);
+    let most = 0;
+    for (let frame = 0; frame < frames; frame++) {
+        for (let k = 0; k < count; k++) operations.push({ kind: "reparent", entity: entities[10 + random(entities.length - 10)], to: entities[random(10)] });
+        await ecs.run(apply);
+        await each();
+        most = Math.max(most, (await ecs.tables()).touched);
+    }
+    return most;
+};
+
+it("holds at most a journal's worth of changed entities for a filtered `up` whose runs are whole passes", async () => {
+    await using ecs = createWorld({ [workers]: 0 });
+    for (let k = 0; k < 4_000; k++) operations.push({ kind: "spawn", local: k % 10, parent: null });
+    await ecs.run(apply);
+    // The first run is a whole pass; the second, with nothing changed, a filtered one.
+    await ecs.run(layoutEveryFrame);
+    await ecs.run(layoutEveryFrame);
+    const most = await mostTouched(ecs, 400, 100, async () => {
+        await ecs.run(moveCamera);
+        await ecs.run(layoutEveryFrame);
+    });
+    expect(most, "most held").toBeLessThanOrEqual(8_192);
+    const want = await expected(ecs, filtered);
+    expect(await actual(ecs, filtered, want.keys())).toEqual(want);
+});
+
+it("holds at most a journal's worth of changed entities for a filtered `up` that stopped running while its tree's other reader runs", async () => {
+    await using ecs = createWorld({ [workers]: 0 });
+    for (let k = 0; k < 4_000; k++) operations.push({ kind: "spawn", local: k % 10, parent: null });
+    await ecs.run(apply);
+    await ecs.run(propagateFull);
+    await ecs.run(propagateFiltered);
+    const most = await mostTouched(ecs, 600, 250, () => ecs.run(propagateFull));
+    expect(most, "most held").toBeLessThanOrEqual(8_192);
+    await ecs.run(propagateFiltered);
+    for (const key of [full, filtered] as const) {
+        const want = await expected(ecs, key);
+        expect(await actual(ecs, key, want.keys()), String(key)).toEqual(want);
+    }
+});

package/src/implementation/world/up-workers.cases.ts

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

package/src/implementation/world/up-workers.fixture.ts

@@ -1,4 +1,4 @@
-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 { workers } from "../../interface/resources/workers.js";
@@ -20,20 +20,16 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(local, { type: { type: "number" } });
-Component.register(world, { type: { type: "number" } });
-Component.register(parent, { type: Entity.schema, reference: "owner" });
 
 const propagate = System.create({
-    name: "upWorkersTest/propagate",
-    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] * 2;
 });
 /** 100 trees, each a root with 40 levels of two children, ordered so storage order isn't depth order. */
-const grow = System.create({ name: "upWorkersTest/grow" }, ({ commands }) => {
+const grow = System.create({}, ({ commands }) => {
     for (let tree = 0; tree < 100; tree++) {
         let level = [commands.spawn([local, world])({ [local]: tree, [world]: 0 })];
         for (let depth = 1; depth < 40; depth++) {
@@ -42,7 +38,7 @@ const grow = System.create({ name: "upWorkersTest/grow" }, ({ commands }) => {
         }
     }
 });
-const nudge = System.create({ name: "upWorkersTest/nudge", components: { write: [local] } }, row => {
+const nudge = System.create({ components: { with: [local] } }, row => {
     if (row[local] === 7) row[local] = 70;
 });
 

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

@@ -1,5 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { afterEach, describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
 import { Entity } from "../../interface/entity/entity.js";
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
@@ -14,29 +14,26 @@ const marked = Symbol("upBrowserTest/marked");
 declare module "@adobe/ecs" {
     interface Components {
         [parent]: { type: Entity; reference: "owner" };
-        [offset]: { type: number };
-        [placed]: { type: number };
+        [offset]: { type: F32 };
+        [placed]: { type: F32 };
         [marked]: { type: true };
     }
 }
 
-Component.register(parent, { type: Entity.schema, reference: "owner" });
-Component.register(offset, { type: { type: "number", precision: 1 } });
-Component.register(placed, { type: { type: "number", precision: 1 } });
-Component.register(marked, { type: { const: true } });
 import { gpuDevice } from "../../interface/resources/gpu-device.js";
 import { workers } from "../../interface/resources/workers.js";
+import type { F32 } from "../../interface/math/index.js";
+import { gpu } from "./gpu.test-helper.js";
 
 const place = System.create({
-    name: "upBrowserTest/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 ? row[offset] : up[placed] + row[offset];
 });
 /** Trees whose children are in two archetypes, so a depth's rows have parents in several. */
-const plant = System.create({ name: "upBrowserTest/plant" }, ({ commands }) => {
+const plant = System.create({}, ({ commands }) => {
     for (let tree = 0; tree < 50; tree++) {
         let level = [commands.spawn([offset, placed])({ [offset]: tree, [placed]: 0 })];
         for (let depth = 1; depth < 12; depth++) {
@@ -71,7 +68,7 @@ const placements = async (gpu: GPUDevice | null): Promise<readonly (number | nul
 };
 
 describe("up on the GPU", () => {
-    it("runs depth by depth, a dispatch per group, as on the CPU", async () => {
+    it.runIf(gpu)("runs depth by depth, a dispatch per group, as on the CPU", async () => {
         const cpu = await placements(null);
         expect(await placements(await device())).toEqual(cpu);
     });

package/src/implementation/world/up.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 { System } from "../../interface/system/system.js";
 import { definitionOf } from "../../interface/registry/index.js";
@@ -30,92 +30,85 @@ 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(label, { type: { type: "string" } });
-Component.register(visible, { type: { type: "boolean" } });
-Component.register(shown, { type: { type: "boolean" } });
-Component.register(anchor, { type: { const: true } });
 
 const ran: string[] = [];
 const propagate = System.create({
-    name: "upTest/propagate",
-    components: { read: [local, label], write: [world] },
-    up: { through: parent, read: [world] },
+    components: { with: [local, label, world] },
+    up: { through: parent },
 }, (row, { up }) => {
     ran.push(row[label]);
     row[world] = (up === null ? 0 : up[world]) + row[local];
 });
 const propagateChanged = System.create({
-    name: "upTest/propagateChanged",
-    components: { read: [local, label], write: [world], changed: [local] },
-    up: { through: parent, read: [world] },
+    components: { with: [local, label, world], changed: [local] },
+    up: { through: parent },
 }, (row, { up }) => {
     ran.push(row[label]);
     row[world] = (up === null ? 0 : up[world]) + row[local];
 });
 const propagateAdded = System.create({
-    name: "upTest/propagateAdded",
-    components: { read: [local, label], write: [world], added: [local] },
-    up: { through: parent, read: [world] },
+    components: { with: [local, label, world], added: [local] },
+    up: { through: parent },
 }, (row, { up }) => {
     ran.push(row[label]);
     row[world] = (up === null ? 0 : up[world]) + row[local];
 });
 const propagateChangedKernel = System.create({
-    name: "upTest/propagateChangedKernel",
-    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];
 });
 const propagateKernel = System.create({
-    name: "upTest/propagateKernel",
-    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];
 });
 
 /** Spawns a root with two trees under it, the grandchild stored before its parent so storage order isn't depth order. */
 const entities: { [name: string]: Entity } = {};
-const spawn = System.create({ name: "upTest/spawn" }, ({ commands }) => {
+const spawn = System.create({}, ({ commands }) => {
     entities.root = commands.spawn([label, local, world])({ [label]: "root", [local]: 1, [world]: 0 });
     entities.grandchild = commands.spawn([label, local, world, parent])({ [label]: "grandchild", [local]: 100, [world]: 0, [parent]: entities.root });
     entities.child = commands.spawn([label, local, world, parent])({ [label]: "child", [local]: 10, [world]: 0, [parent]: entities.root });
     entities.other = commands.spawn([label, local, world])({ [label]: "other", [local]: 1000, [world]: 0 });
 });
-const nest = System.create({ name: "upTest/nest" }, ({ commands }) => { commands.add(entities.grandchild, parent, entities.child); });
-const bump = System.create({ name: "upTest/bump", input: { type: "object", properties: { entity: Entity.schema } } }, ({ input, commands }) => {
+const nest = System.create({}, ({ commands }) => { commands.add(entities.grandchild, parent, entities.child); });
+const bump = System.create({}, ({ commands }, input: { readonly entity: Entity }) => {
     commands.add(input.entity, local, 2);
 });
-const loop = System.create({ name: "upTest/loop" }, ({ commands }) => {
+const loop = System.create({}, ({ commands }) => {
     commands.add(entities.root, parent, entities.grandchild);
     commands.spawn([label, local, world, parent])({ [label]: "under", [local]: 5, [world]: 0, [parent]: entities.child });
 });
 /** Puts the root under the grandchild, two levels below it, then under `other`. */
-const close = System.create({ name: "upTest/close" }, ({ commands }) => { commands.add(entities.root, parent, entities.grandchild); });
-const open = System.create({ name: "upTest/open" }, ({ commands }) => { commands.add(entities.root, parent, entities.other); });
-const orphan = System.create({ name: "upTest/orphan" }, ({ commands }) => { commands.remove(entities.grandchild, parent); });
+const close = System.create({}, ({ commands }) => { commands.add(entities.root, parent, entities.grandchild); });
+const open = System.create({}, ({ commands }) => { commands.add(entities.root, parent, entities.other); });
+const orphan = System.create({}, ({ commands }) => { commands.remove(entities.grandchild, parent); });
+/** Spawns `count` leaves under the grandchild, more than the journal keeps for a world this small. */
+const bulk: Entity[] = [];
+const bulkUnder = System.create({}, ({ commands }, input: { readonly count: number }) => {
+    bulk.length = 0;
+    for (let i = 0; i < input.count; i++) bulk.push(commands.spawn([label, local, world, parent])({ [label]: "bulk", [local]: 1, [world]: 0, [parent]: entities.grandchild }));
+});
 
 const worlds = async (value: (entity: Entity) => Promise<number | null>): Promise<{ [name: string]: number | null }> =>
     Object.fromEntries(await Promise.all(Object.entries(entities).map(async ([name, entity]) => [name, await value(entity)])));
 
 const show = System.create({
-    name: "upTest/show",
-    kernel: "cpu",
-    components: { read: [visible], write: [shown] },
-    up: { through: parent, read: [shown] },
+    kernel: true,
+    components: { with: [visible, shown] },
+    up: { through: parent },
 }, (row, { up }) => {
     row[shown] = up === null ? row[visible] : up[shown] && row[visible];
 });
 
 /** Children of one archetype whose parents are in three: a matched one, one the query doesn't match, and one without `world`. */
 const mixed: { [name: string]: Entity } = {};
-const spawnMixed = System.create({ name: "upTest/spawnMixed" }, ({ commands }) => {
+const spawnMixed = System.create({}, ({ commands }) => {
     mixed.root = commands.spawn([local, world])({ [local]: 1, [world]: 0 });
     mixed.anchored = commands.spawn([local, world, anchor])({ [local]: 2, [world]: 0, [anchor]: true });
     mixed.unmatched = commands.spawn([world])({ [world]: 50 });
@@ -125,10 +118,10 @@ const spawnMixed = System.create({ name: "upTest/spawnMixed" }, ({ commands }) =
     mixed.underAnchored = commands.spawn([local, world, parent])({ [local]: 10, [world]: 0, [parent]: mixed.anchored });
     mixed.underBare = commands.spawn([local, world, parent])({ [local]: 10, [world]: 0, [parent]: mixed.bare });
 });
-const growParents = System.create({ name: "upTest/growParents" }, ({ commands }) => {
+const growParents = System.create({}, ({ commands }) => {
     for (let i = 0; i < 100; i++) commands.spawn([local, world, anchor])({ [local]: 0, [world]: 0, [anchor]: true });
 });
-const shift = System.create({ name: "upTest/shift", components: { write: [local], has: [anchor] } }, row => { row[local] += 1; });
+const shift = System.create({ components: { with: [local, anchor] } }, row => { row[local] += 1; });
 
 describe("up", () => {
     for (const [kind, system] of [["main-thread", propagate], ["kernel", propagateKernel]] as const) {
@@ -197,6 +190,27 @@ describe("up", () => {
         expect(await read(ecs, entities.grandchild, world)).toBe(100);
     });
 
+    it("runs every row after a spawn outruns the journal, with change filters, then only the rows that changed", async () => {
+        await using ecs = createWorld({ [workers]: 0 });
+        await ecs.run(spawn);
+        await ecs.run(nest);
+        await ecs.run(propagateChanged);
+        await ecs.run(bulkUnder, { count: 5000 });
+        ran.length = 0;
+        await ecs.run(propagateChanged);
+        expect(ran.length).toBe(4 + 5000);
+        expect(ran.slice(0, 4).sort()).toEqual(["child", "grandchild", "other", "root"]);
+        expect(await readEach(ecs, bulk.slice(0, 3), world)).toEqual([112, 112, 112]);
+        ran.length = 0;
+        await ecs.run(bump, { entity: entities.grandchild });
+        await ecs.run(propagateChanged);
+        expect(ran.length).toBe(1 + 5000);
+        expect(await readEach(ecs, [entities.grandchild, bulk[4999]], world)).toEqual([13, 14]);
+        ran.length = 0;
+        await ecs.run(propagateChanged);
+        expect(ran).toEqual([]);
+    });
+
     it("finds a cycle a reparent closes after the tree was built, and runs its rows again once it opens", async () => {
         await using ecs = createWorld({ [workers]: 0 });
         await ecs.run(spawn);
@@ -242,7 +256,7 @@ describe("up", () => {
         await using ecs = createWorld({ [workers]: 0 });
         await ecs.run(spawnMixed);
         await ecs.run(propagateKernel);
-        await ecs.run(System.create({ name: "upTest/moveUnmatched" }, ({ commands }) => { commands.add(mixed.unmatched, [anchor, world], { [anchor]: true, [world]: 80 }); }));
+        await ecs.run(System.create({}, ({ commands }) => { commands.add(mixed.unmatched, [anchor, world], { [anchor]: true, [world]: 80 }); }));
         await ecs.run(propagateKernel);
         expect(await read(ecs, mixed.underUnmatched, world)).toBe(90);
     });
@@ -250,7 +264,7 @@ describe("up", () => {
     it("reads booleans through up", async () => {
         await using ecs = createWorld({ [workers]: 0 });
         const tree: Entity[] = [];
-        await ecs.run(System.create({ name: "upTest/spawnShown" }, ({ commands }) => {
+        await ecs.run(System.create({}, ({ commands }) => {
             const top = commands.spawn([visible, shown])({ [visible]: false, [shown]: true });
             tree.push(top, commands.spawn([visible, shown, parent])({ [visible]: true, [shown]: true, [parent]: top }));
             const other = commands.spawn([visible, shown])({ [visible]: true, [shown]: false });
@@ -279,6 +293,6 @@ describe("up", () => {
 
     it("rejects a through that isn't a reference, for untyped declarations", async () => {
         // @ts-expect-error through is a reference component
-        expect(() => System.create({ name: "upTest/untyped", components: { write: [world] }, up: { through: local, read: [world] } }, row => { row[world] = 0; })).toThrow('System "upTest/untyped": up.through "upTest/local" isn\'t a reference component.');
+        expect(() => System.create({ components: { with: [world] }, up: { through: local } }, row => { row[world] = 0; })).toThrow('up.through "upTest/local" isn\'t a reference component.');
     });
 });