@adobe/ecs 0.0.0-stage → 0.1.0

package/src/implementation/world/observe-factories.test.ts

@@ -0,0 +1,303 @@
+import { describe, expect, it, vi } from "vitest";
+import { Component } from "../../interface/component/component.js";
+import type { Entity } from "../../interface/entity/entity.js";
+import { Resource } from "../../interface/resource/resource.js";
+import { workers } from "../../interface/resources/workers.js";
+import { System } from "../../interface/system/system.js";
+import { Observe } from "../../observe/index.js";
+import type { World } from "../../interface/world/world.js";
+import { createWorld, join, type CreatedWorld } from "./create.js";
+import { tablesOf } from "./join.js";
+import { settle } from "./observe.test-helper.js";
+import { runReported } from "./reports.test-helper.js";
+
+// How the internal factories of `src/observe` run: systems shared by shape, first values batched or given at once, warm
+// reads, and what they hold released once idle.
+
+const amount = Symbol("observeFactoriesTest/amount");
+const other = Symbol("observeFactoriesTest/other");
+const level = Symbol("observeFactoriesTest/level");
+declare module "@adobe/ecs" {
+    interface Components {
+        [amount]: { type: number };
+        [other]: { type: number };
+    }
+    interface Resources {
+        [level]: { type: number };
+    }
+}
+Component.register(amount, { type: { type: "number" } });
+Component.register(other, { type: { type: "number" } });
+Resource.register(level, { type: { type: "number", default: 0 } });
+
+let spawned: Entity[] = [];
+const seed = System.create({ name: "observeFactoriesTest/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+    spawned = [];
+    for (let i = 0; i < input.count; i++) spawned.push(commands.spawn([amount])({ [amount]: i }));
+});
+const grow = System.create({ name: "observeFactoriesTest/grow", components: { write: [amount] } }, row => { row[amount] += 1; });
+const raise = System.create({ name: "observeFactoriesTest/raise", resources: { write: [level] } }, ({ resources }) => { resources[level] += 1; });
+const nothing = System.create({ name: "observeFactoriesTest/nothing" }, () => {});
+
+/** Counts passes: the observer passes after each run's sync point. */
+const passes = { count: 0 };
+const counter = System.create({ name: "observeFactoriesTest/counter", observer: true }, () => { passes.count++; });
+
+/**
+ * A world of `count` entities, each amount its index and one more, at level 1: the runs below registered, so runners
+ * count only what observers hold.
+ */
+const seeded = async (count: number): Promise<CreatedWorld> => {
+    const world = createWorld({ [workers]: 0 });
+    await world.run(seed, { count });
+    await world.run(nothing);
+    await world.run(raise);
+    await world.run(grow);
+    await settle(world);
+    return world;
+};
+
+const runnersOf = async (world: CreatedWorld): Promise<number> => (await world.tables()).runners;
+
+describe("observer factories", () => {
+    it("share one observer system among every observer of one shape, whatever their entities, where values and pages", async () => {
+        await using world = await seeded(100);
+        const stops = [Observe.entity(world, spawned[0], { required: [amount] })(() => {}), Observe.select(world, { required: [amount], where: { [amount]: 0 }, page: { offset: 0, limit: 5 } })(() => {})];
+        await settle(world);
+        const before = await runnersOf(world);
+        for (let i = 1; i < 100; i++) stops.push(Observe.entity(world, spawned[i], { required: [amount] })(() => {}));
+        for (let i = 1; i < 10; i++) stops.push(Observe.select(world, { required: [amount], where: { [amount]: { ">": i } }, page: { offset: i, limit: 5 } })(() => {}));
+        await settle(world);
+        expect(await runnersOf(world)).toBe(before);
+        for (const stop of stops) stop();
+    });
+
+    it("give a value they hold while subscribing, and batch the rest into the runs of one flush", async () => {
+        await using world = await seeded(10);
+        world.add(counter);
+        await settle(world);
+        passes.count = 0;
+        const values: number[] = [];
+        for (let i = 0; i < 10; i++) Observe.entity(world, spawned[i], { required: [amount] })(value => values.push(value?.[amount] ?? -1));
+        Observe.select(world, { required: [amount], where: { [amount]: { "<": 5 } } })(() => {});
+        Observe.select(world, { required: [amount], where: { [amount]: { "<": 7 } } })(() => {});
+        expect(values).toEqual([]);
+        await settle(world);
+        // A scan for both selections, the delivering run, and the settling run.
+        expect(passes.count).toBe(3);
+        expect(values).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+        const warm: number[] = [];
+        Observe.entity(world, spawned[3], { required: [amount] })(value => warm.push(value?.[amount] ?? -1))();
+        expect(warm).toEqual([4]);
+    });
+
+    it("stay warm for reads of first values in a loop, then release what they hold once found idle in three passes", async () => {
+        await using world = await seeded(10);
+        await Observe.toPromise(Observe.resource(world, level));
+        await Observe.toPromise(Observe.entity(world, spawned[0], { required: [amount] }));
+        const held = await runnersOf(world);
+        for (let i = 0; i < 3; i++) {
+            const values: number[] = [];
+            Observe.resource(world, level)(value => values.push(value))();
+            Observe.entity(world, spawned[0], { required: [amount] })(value => values.push(value?.[amount] ?? -1))();
+            expect(values).toEqual([1 + i, 1 + i]);
+            await world.run(raise);
+            await world.run(grow);
+        }
+        expect(await runnersOf(world)).toBe(held);
+        // The resource's and the entity's systems.
+        await world.run(nothing);
+        expect(await runnersOf(world)).toBe(held - 2);
+        // Used again, they're added again, and cold.
+        const values: number[] = [];
+        Observe.resource(world, level)(value => values.push(value))();
+        expect(values).toEqual([]);
+        expect(await Observe.toPromise(Observe.resource(world, level))).toBe(4);
+        expect(await runnersOf(world)).toBe(held - 1);
+        // An entity observer's system, added again, reads through its new lookups.
+        const entities: unknown[] = [];
+        const stop = Observe.entity(world, spawned[0], { required: [amount] })(value => entities.push(value?.[amount]));
+        await settle(world);
+        await world.run(grow);
+        await world.run(System.create({ name: "observeFactoriesTest/growOthers", components: { write: [amount] } }, row => {
+            if (row.entity !== spawned[0]) row[amount] += 1;
+        }));
+        expect(entities).toEqual([4, 5]);
+        stop();
+    });
+
+    it("track a query only once a subscriber outlives its first value", async () => {
+        await using world = await seeded(10);
+        expect(await Observe.toPromise(Observe.count(world, { required: [amount], where: { [amount]: { ">=": 5 } } }))).toBe(6);
+        const scanned = await runnersOf(world);
+        await world.run(nothing);
+        expect(await runnersOf(world)).toBe(scanned);
+        const counts: number[] = [];
+        const stop = Observe.count(world, { required: [amount], where: { [amount]: { ">=": 5 } } })(value => counts.push(value));
+        await settle(world);
+        expect(await runnersOf(world)).toBe(scanned + 1);
+        await world.run(grow);
+        expect(counts).toEqual([6, 7]);
+        stop();
+        await world.run(nothing);
+        await world.run(nothing);
+        await world.run(nothing);
+        expect(await runnersOf(world)).toBe(scanned);
+    });
+
+    it("notify subscribers whose first value was one held, while subscribing, of every later change", async () => {
+        await using world = await seeded(3);
+        const held = [Observe.resource(world, level)(() => {}), Observe.entity(world, spawned[0], { required: [amount] })(() => {}), Observe.count(world, { required: [amount], where: { [amount]: { ">": 1 } } })(() => {})];
+        await settle(world);
+        const levels: number[] = [];
+        const amounts: number[] = [];
+        const counts: number[] = [];
+        const stops = [
+            Observe.resource(world, level)(value => levels.push(value)),
+            Observe.entity(world, spawned[0], { required: [amount] })(value => amounts.push(value?.[amount] ?? -1)),
+            Observe.count(world, { required: [amount], where: { [amount]: { ">": 1 } } })(value => counts.push(value)),
+        ];
+        await world.run(raise);
+        await world.run(grow);
+        await world.run(grow);
+        expect([levels, amounts, counts]).toEqual([[1, 2], [1, 2, 3], [2, 3]]);
+        for (const stop of [...held, ...stops]) stop();
+    });
+
+    it("keep the values of observers of another world apart", async () => {
+        await using first = await seeded(3);
+        await using second = await seeded(5);
+        expect(await Promise.all([Observe.toPromise(Observe.count(first, {})), Observe.toPromise(Observe.count(second, {}))])).toEqual([3, 5]);
+        await first.run(raise);
+        expect(await Promise.all([Observe.toPromise(Observe.resource(first, level)), Observe.toPromise(Observe.resource(second, level))])).toEqual([2, 1]);
+    });
+
+    it("read only what they list, so a write elsewhere notifies nothing", async () => {
+        await using world = await seeded(3);
+        const writeOther = System.create({ name: "observeFactoriesTest/writeOther", components: { write: [other] } }, row => { row[other] = 1; });
+        let notified = 0;
+        Observe.entity(world, spawned[0], { required: [amount] })(() => notified++);
+        Observe.select(world, { required: [amount], order: { [amount]: false }, page: { offset: 0, limit: 2 } })(() => notified++);
+        Observe.count(world, { required: [amount] })(() => notified++);
+        await settle(world);
+        await world.run(writeOther);
+        await world.run(nothing);
+        expect(notified).toBe(3);
+    });
+
+    it("rethrow only their own systems' failures from their runs, not those of observer systems the world added", async () => {
+        await using world = await seeded(3);
+        const failing = System.create({ name: "observeFactoriesTest/failing", observer: true }, () => { throw new Error("added failed"); });
+        world.add(failing);
+        const caught: unknown[] = [];
+        const original = globalThis.queueMicrotask;
+        vi.spyOn(globalThis, "queueMicrotask").mockImplementation(callback => original(() => {
+            try {
+                callback();
+            }
+            catch (error) {
+                caught.push(error);
+            }
+        }));
+        try {
+            // Cold first values, from runs of the factories' own, each running the added system too.
+            expect(await Observe.toPromise(Observe.resource(world, level))).toBe(1);
+            expect(await Observe.toPromise(Observe.count(world, { required: [amount] }))).toBe(3);
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        finally {
+            vi.restoreAllMocks();
+        }
+        expect(caught).toEqual([]);
+        // The world's runs still report it.
+        expect((await runReported(world, nothing)).failures.map(failure => failure.name)).toEqual(["observeFactoriesTest/failing"]);
+    });
+});
+
+/** A world of `count` entities as `seeded` makes them, and a thread joined to it through a channel. */
+const seededJoined = async (count: number): Promise<{ readonly world: CreatedWorld; readonly remote: World; readonly close: () => Promise<void> }> => {
+    const world = await seeded(count);
+    const channel = new MessageChannel();
+    world.share(channel.port1);
+    const remote = join(channel.port2, { threads: [] });
+    await remote.run(nothing);
+    return {
+        world, remote,
+        close: async () => {
+            await remote.dispose();
+            await world.dispose();
+        },
+    };
+};
+
+/** How many observer systems are placed on a joined thread. */
+const placedOn = (remote: World): number => tablesOf.get(remote)?.().observer ?? -1;
+
+/** A few turns of the event loop, which a joined thread's posts need. */
+const turns = async (count = 20): Promise<void> => {
+    for (let turn = 0; turn < count; turn++) await new Promise(resolve => setTimeout(resolve, 0));
+};
+
+describe("observer factories on a joined thread", () => {
+    it("share one observer system there among every observer of one shape, and notify each of every later change", async () => {
+        const { world, remote, close } = await seededJoined(20);
+        const amounts: number[] = [];
+        const stops = [
+            Observe.entity(remote, spawned[0], { required: [amount] })(value => amounts.push(value?.[amount] ?? -1)),
+            Observe.select(remote, { required: [amount], where: { [amount]: { ">": 10 } }, order: { [amount]: false }, page: { offset: 0, limit: 3 } })(() => {}),
+            Observe.resource(remote, level)(() => {}),
+        ];
+        await Observe.toPromise(Observe.count(remote, { required: [amount] }));
+        const placed = placedOn(remote);
+        for (let i = 1; i < 20; i++) stops.push(Observe.entity(remote, spawned[i], { required: [amount] })(() => {}));
+        for (let i = 1; i < 5; i++) stops.push(Observe.select(remote, { required: [amount], where: { [amount]: { ">": i } }, order: { [amount]: false }, page: { offset: i, limit: 3 } })(() => {}));
+        const levels: number[] = [];
+        stops.push(Observe.resource(remote, level)(value => levels.push(value)));
+        expect(await Observe.toPromise(Observe.select(remote, { required: [amount], where: { [amount]: { ">": 1 } }, order: { [amount]: false }, page: { offset: 1, limit: 3 } }))).toEqual([spawned[18], spawned[17], spawned[16]]);
+        expect(placedOn(remote)).toBe(placed);
+        // Held, so given while subscribing.
+        expect(levels).toEqual([1]);
+        await world.run(raise);
+        await world.run(grow);
+        await turns();
+        expect([amounts, levels]).toEqual([[1, 2], [1, 2]]);
+        for (const stop of stops) stop();
+        await close();
+    });
+
+    it("give cold first values from a run after the thread's runs called before subscribing", async () => {
+        const { remote, close } = await seededJoined(3);
+        void remote.run(seed, { count: 5 });
+        const count = Observe.toPromise(Observe.count(remote, { required: [amount] }));
+        void remote.run(raise);
+        const resource = Observe.toPromise(Observe.resource(remote, level));
+        expect(await Promise.all([count, resource])).toEqual([8, 2]);
+        await close();
+    });
+
+    it("release what they place there once found idle in three turns that ran them", async () => {
+        const { world, remote, close } = await seededJoined(3);
+        const before = placedOn(remote);
+        const stop = Observe.entity(remote, spawned[0], { required: [amount] })(() => {});
+        expect(await Observe.toPromise(Observe.resource(remote, level))).toBe(1);
+        expect(placedOn(remote)).toBe(before + 2);
+        stop();
+        for (let k = 0; k < 4; k++) {
+            await world.run(raise);
+            await turns(5);
+        }
+        expect(placedOn(remote)).toBe(before);
+        // Used again, added again.
+        expect(await Observe.toPromise(Observe.resource(remote, level))).toBe(5);
+        await close();
+    });
+});
+
+describe("Observe.toPromise", () => {
+    it("resolves to the first value and stops observing, even when it comes while subscribing", async () => {
+        let stopped = 0;
+        const observe: Observe<number> = notify => { notify(1); notify(2); return () => { stopped++; }; };
+        expect(await Observe.toPromise(observe)).toBe(1);
+        expect(stopped).toBe(1);
+    });
+});

package/src/implementation/world/observe-joined-cases.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, it, vi } from "vitest";
+import { Component } from "../../interface/component/component.js";
+import { Entity } from "../../interface/entity/entity.js";
+import { Resource } from "../../interface/resource/resource.js";
+import { workers } from "../../interface/resources/workers.js";
+import { System } from "../../interface/system/system.js";
+import type { World } from "../../interface/world/world.js";
+import { createWorld, join, type CreatedWorld } from "./create.js";
+import { Observe } from "../../observe/index.js";
+import { reportOf } from "./reports.test-helper.js";
+
+// The observer factories of `src/observe` on a joined thread's world, with the world and the thread on this one,
+// joined through a MessageChannel. Each case waits for the value it expects, so it holds whenever values come.
+
+const point = Symbol("observeJoinedTest/point");
+const label = Symbol("observeJoinedTest/label");
+const marked = Symbol("observeJoinedTest/marked");
+const total = Symbol("observeJoinedTest/total");
+const names = Symbol("observeJoinedTest/names");
+const place = Symbol("observeJoinedTest/place");
+const caption = Symbol("observeJoinedTest/caption");
+const widget = Symbol("observeJoinedTest/widget");
+const kept = Symbol("observeJoinedTest/kept");
+declare module "@adobe/ecs" {
+    export interface Threads {
+        observeJoinedTest: true;
+    }
+    export interface Components {
+        [point]: { type: readonly [number, number] };
+        [label]: { type: string };
+        [marked]: { type: true };
+        [place]: { type: number };
+        [caption]: { type: { readonly text: string } | null; thread: "observeJoinedTest" };
+        [widget]: { type: { readonly draw: () => string } | null; thread: "observeJoinedTest" };
+        [kept]: { type: string };
+    }
+    export interface Resources {
+        [total]: { type: number };
+        [names]: { type: readonly string[] };
+    }
+}
+Component.register(point, { type: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2 } });
+Component.register(label, { type: { type: "string" } });
+Component.register(marked, { type: { const: true } });
+Component.register(place, { type: { type: "number" } });
+/** The caption's start, which a command here gives it by this value. */
+const none = { text: "none" };
+Component.register(caption, { type: { anyOf: [{ type: "object", properties: { text: { type: "string" } } }, { type: "null" }], default: none }, thread: "observeJoinedTest" });
+Component.register(widget, { thread: "observeJoinedTest" });
+Component.register(kept, { type: { type: "string" } });
+Resource.register(total, { type: { type: "number", default: 0 } });
+Resource.register(names, { type: { type: "array", items: { type: "string" }, default: [] } });
+
+const add = System.create({ name: "observeJoinedTest/add", input: { type: "object", properties: { amount: { type: "number" } } }, resources: { write: [total] } }, ({ input, resources }) => {
+    resources[total] = resources[total] * 10 + input.amount;
+});
+const spawn = System.create({ name: "observeJoinedTest/spawn", input: { type: "object", properties: { x: { type: "number" } } } }, ({ input, commands }) => {
+    commands.spawn([point, label, marked])({ [point]: [input.x, -input.x], [label]: `p${input.x}` });
+});
+const spawnPlaced = System.create({ name: "observeJoinedTest/spawnPlaced", input: { type: "object", properties: { x: { type: "number" } } } }, ({ input, commands }) => {
+    commands.spawn([place, caption, widget, kept])({ [place]: input.x, [widget]: null, [kept]: `k${input.x}` });
+});
+const nullCaptions = System.create({ name: "observeJoinedTest/nullCaptions", components: { has: [caption, place] } }, (row, { commands }) => { commands.add(row.entity, caption, null); });
+const restartCaptions = System.create({ name: "observeJoinedTest/restartCaptions", components: { has: [caption, place] } }, (row, { commands }) => { commands.add(row.entity, caption, none); });
+const dropCaptions = System.create({ name: "observeJoinedTest/dropCaptions", components: { has: [caption] } }, (row, { commands }) => { commands.remove(row.entity, caption); });
+
+/** A world shared with a thread joined through a channel claiming `threads`, and the joined world. */
+const joined = (threads: readonly "observeJoinedTest"[] = []): { readonly world: CreatedWorld; readonly remote: World } => {
+    const world = createWorld({ [workers]: 0 });
+    const channel = new MessageChannel();
+    world.share(channel.port1);
+    const remote = join(channel.port2, { threads });
+    return { world, remote };
+};
+
+/** The next value an observer gives that `accept` takes. */
+const until = <T>(observe: (notify: (value: T) => void) => () => void, accept: (value: T) => boolean): Promise<T> => new Promise(resolve => {
+    let stop: (() => void) | null = null;
+    let done = false;
+    stop = observe(value => {
+        if (done || !accept(value)) return;
+        done = true;
+        queueMicrotask(() => stop?.());
+        resolve(value);
+    });
+    if (done) stop();
+});
+
+/** Errors thrown out of band while `run` runs, as uncaught errors would be, caught instead. */
+const catching = async (run: () => Promise<void>): Promise<unknown[]> => {
+    const caught: unknown[] = [];
+    const original = globalThis.queueMicrotask;
+    vi.spyOn(globalThis, "queueMicrotask").mockImplementation(callback => original(() => {
+        try {
+            callback();
+        }
+        catch (error) {
+            caught.push(error);
+        }
+    }));
+    try {
+        await run();
+    }
+    finally {
+        vi.restoreAllMocks();
+    }
+    return caught;
+};
+
+/** Once the thread shared last is joined, its claims made. */
+const joinedStatus = (world: CreatedWorld) => until(world.threads, threads => threads.at(-1)?.status === "joined");
+
+/** The entity a run of `spawnPlaced` spawned. */
+const spawnOne = async (world: World, x: number): Promise<Entity> => {
+    await world.run(spawnPlaced, { x });
+    const [entity] = await until(Observe.select(world, { required: [place], where: { [place]: x } }), entities => entities.length === 1);
+    return entity;
+};
+
+describe("observer factories on a joined thread", () => {
+    it("read the strings the world's thread writes, which live in shared memory", async () => {
+        const { world, remote } = joined();
+        await world.run(spawn, { x: 3 });
+        const [entity] = await until(Observe.select(remote, { required: [point], where: { [point]: [3, -3] } }), entities => entities.length === 1);
+        expect(await until(Observe.entity(remote, entity, { required: [label] }), value => value !== null)).toEqual({ [label]: "p3" });
+        await remote.dispose();
+        await world.dispose();
+    });
+    it("give values of resources, entities, select and count, then each newer one", async () => {
+        const { world, remote } = joined();
+        const first: unknown[] = [];
+        const stop = Observe.resource(remote, total)(value => first.push(value));
+        // Never during the subscribing call: the thread holds nothing yet.
+        expect(first).toEqual([]);
+        expect(await until(Observe.resource(remote, total), value => value === 0)).toBe(0);
+        stop();
+        await world.run(add, { amount: 7 });
+        expect(await until(Observe.resource(remote, total), value => value === 7)).toBe(7);
+        await remote.run(spawn, { x: 1 });
+        await remote.run(spawn, { x: 2 });
+        const selected = await until(Observe.select(remote, { required: [point], order: { [point]: false } }), entities => entities.length === 2);
+        expect(await until(Observe.count(remote, { required: [point], where: { [point]: [2, -2] } }), count => count === 1)).toBe(1);
+        const listed = await until(Observe.entity(remote, selected[0], { required: [point], optional: [marked] }), value => value !== null);
+        expect(listed).toEqual({ [point]: [2, -2], [marked]: true });
+        await remote.dispose();
+        await world.dispose();
+    });
+
+    it("stop notifying once stopped", async () => {
+        const { world, remote } = joined();
+        const seen: number[] = [];
+        const stop = Observe.resource(remote, total)(value => seen.push(value));
+        await until(Observe.resource(remote, total), value => value === 0);
+        stop();
+        await world.run(add, { amount: 1 });
+        await until(Observe.resource(remote, total), value => value === 1);
+        expect(seen).toEqual([0]);
+        await remote.dispose();
+        await world.dispose();
+    });
+
+    it("give one that fell behind the newest value", async () => {
+        const { world, remote } = joined();
+        const seen: number[] = [];
+        Observe.resource(remote, total)(value => seen.push(value));
+        await until(Observe.resource(remote, total), value => value === 0);
+        for (let k = 1; k <= 5; k++) await world.run(add, { amount: k });
+        await until(Observe.resource(remote, total), value => value === 12345);
+        await new Promise(resolve => setTimeout(resolve, 10));
+        expect(seen.at(-1)).toBe(12345);
+        expect(seen.length).toBeLessThanOrEqual(6);
+        await remote.dispose();
+        await world.dispose();
+    });
+
+    it("throw for one that reads objects of the world's thread, or looks up by its keys of strings", async () => {
+        const { world, remote } = joined();
+        const ignore = (): void => {};
+        // The factories make nothing until subscribed, so they throw when subscribed.
+        const made = <T>(make: () => (notify: (value: T) => void) => () => void) => () => make()(ignore);
+        expect(made(() => Observe.resource(remote, names))).toThrow('reads "observeJoinedTest/names", an object, which lives on another thread');
+        expect(made(() => Observe.select(remote, { required: [label], where: { [label]: "a" } }))).toThrow(/"observeJoinedTest\/label"[^.]*a string, which the world's thread keeps keys of/);
+        // What threw holds nothing: observers it could make still work.
+        expect(await until(Observe.resource(remote, total), value => value === 0)).toBe(0);
+        await remote.dispose();
+        await world.dispose();
+    });
+
+    it("read the objects of the threads the thread fills, at their starts or null as the world's commands give them", async () => {
+        const { world, remote } = joined(["observeJoinedTest"]);
+        await joinedStatus(world);
+        const entity = await spawnOne(world, 1);
+        const listed = Observe.entity(remote, entity, { required: [place, caption], optional: [widget] });
+        expect(await until(listed, value => value !== null)).toEqual({ [place]: 1, [caption]: none, [widget]: null });
+        await world.run(nullCaptions);
+        expect(await until(listed, value => value?.[caption] === null)).toEqual({ [place]: 1, [caption]: null, [widget]: null });
+        await world.run(restartCaptions);
+        expect(await until(listed, value => value?.[caption]?.text === "none")).toEqual({ [place]: 1, [caption]: none, [widget]: null });
+        await world.run(dropCaptions);
+        expect(await until(listed, value => value === null)).toBeNull();
+        expect(await until(Observe.entity(remote, entity, { required: [place], optional: [caption] }), value => value !== null)).toEqual({ [place]: 1 });
+        await remote.dispose();
+        await world.dispose();
+    });
+
+    it("fail on the world's thread for one that reads objects a joined thread fills", async () => {
+        const { world, remote } = joined(["observeJoinedTest"]);
+        await joinedStatus(world);
+        const entity = await spawnOne(world, 3);
+        const values: unknown[] = [];
+        const observe = (): void => {
+            Observe.entity(world, entity, { required: [caption] })(value => values.push(value));
+            Observe.select(world, { required: [place, caption], where: { [caption]: none } })(() => {});
+        };
+        const reported: string[] = [];
+        const caught = await catching(async () => {
+            observe();
+            const runs: number[] = [];
+            for (let k = 4; k < 6; k++) runs.push(await world.run(spawnPlaced, { x: k }));
+            await new Promise(resolve => setTimeout(resolve, 10));
+            for (const run of runs) for (const failure of (await reportOf(world, run)).failures) reported.push(failure.message);
+        });
+        // The entity observer's system, added, fails in a run's report; the selection's scan, run, rejects, rethrown.
+        expect([...reported, ...caught.map(String)]).toEqual([
+            expect.stringMatching(/^System "Observe\.entity\(observeJoinedTest\/caption\).*runs on thread "observeJoinedTest", which a joined thread fills, and has no id/),
+            expect.stringMatching(/System "Observe\.select\(observeJoinedTest\/place, observeJoinedTest\/caption\).*runs on thread "observeJoinedTest", which a joined thread fills, and has no id/),
+        ]);
+        expect(values).toEqual([]);
+        await remote.dispose();
+        await world.dispose();
+    });
+});