@adobe/ecs 0.0.0-stage → 0.2.0

package/src/implementation/world/joining-worker.fixture.ts

@@ -0,0 +1,109 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { MessagePort as NodeMessagePort } from "node:worker_threads";
+import { workers } from "../../interface/resources/workers.js";
+import { System } from "../../interface/system/system.js";
+import { Observe } from "../../observe/index.js";
+import { createWorld, join } from "./create.js";
+import { threadLock } from "./joining.js";
+import { scopeChannel } from "./port.js";
+import { drive, idle, names, total, until, type Driven } from "./joining.test-helper.js";
+
+/** A thread joining a world through the port it's sent and driving it, or holding a world it shares through it. */
+
+/** A system only this thread imports, which a world elsewhere never did. */
+const unimportedByMain = System.create({}, () => {});
+
+type Port = MessagePort | NodeMessagePort;
+export type ToJoiningWorker =
+    | { readonly kind: "join"; readonly port: Port; readonly threads: readonly "main"[] }
+    | { readonly kind: "idle"; readonly port: Port; readonly threads: readonly "main"[] }
+    /** Join, and add an observer system hearing `total`, as the join resolved. */
+    | { readonly kind: "listen"; readonly port: Port; readonly threads: readonly "main"[] }
+    /** What the observer system `listen` added heard, once it heard `value`, or after a few seconds. */
+    | { readonly kind: "heard"; readonly value: number }
+    /** Join, then end this thread on the turn the join resolved, before the world heard it finished. */
+    | { readonly kind: "exit on join"; readonly port: Port; readonly threads: readonly "main"[] }
+    | { readonly kind: "host"; readonly port: Port }
+    /** Hold a world shared through the port, then block this thread for good, so the world never answers a join. */
+    | { readonly kind: "host and stall"; readonly port: Port }
+    /** Hold a world shared through this worker's own scope, which this fixture's messages share. */
+    | { readonly kind: "host scope" }
+    /** Once the thread that joined has left: the world's state, and the reports of the runs it drove. */
+    | { readonly kind: "state"; readonly driven?: Driven };
+export type FromJoiningWorker =
+    | { readonly kind: "driven"; readonly driven: Driven }
+    | { readonly kind: "joined"; readonly ran: string }
+    | { readonly kind: "listening"; readonly joined: string }
+    | { readonly kind: "heard"; readonly heard: readonly number[] }
+    | { readonly kind: "shared" }
+    | { readonly kind: "state"; readonly driven: Driven | null; readonly total: number; readonly names: readonly string[]; readonly status: string | null };
+
+const channel = scopeChannel<FromJoiningWorker, ToJoiningWorker>();
+let hosted: ReturnType<typeof createWorld> | null = null;
+/** What the observer system `listen` adds heard. */
+const heard: number[] = [];
+const hear = System.create({ observer: true }, ({ resources }) => { heard.push(resources[total]); });
+const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
+/** Ends this thread at once: node's worker exits, and a browser worker closes, dropping the tasks it queued. */
+const exit = (): void => {
+    if (globalThis.process?.versions?.node !== undefined) globalThis.process.exit(0);
+    else self.close();
+};
+channel.onMessage(async message => {
+    // The world's own messages, where it shares the scope.
+    if ("protocol" in message) return;
+    if (message.kind === "host scope") {
+        const world = createWorld({ [workers]: 0 });
+        const scope = globalThis.process?.getBuiltinModule?.("node:worker_threads")?.parentPort ?? self;
+        void world.share(scope);
+        hosted = world;
+        channel.post({ kind: "shared" });
+    }
+    else if (message.kind === "join") {
+        const remote = await join(message.port, { threads: message.threads });
+        channel.post({ kind: "driven", driven: await drive(remote, unimportedByMain) });
+        await remote.dispose();
+    }
+    else if (message.kind === "idle") {
+        // Joins and stays, its one run's outcome posted, or why it didn't join.
+        const ran = await join(message.port, { threads: message.threads }).then(remote => remote.run(idle)).then(() => "ran", messageOf);
+        channel.post({ kind: "joined", ran });
+    }
+    else if (message.kind === "listen") {
+        const joined = await join(message.port, { threads: message.threads }).then(remote => {
+            remote.add(hear);
+            return "joined";
+        }, messageOf);
+        channel.post({ kind: "listening", joined });
+    }
+    else if (message.kind === "heard") {
+        const end = performance.now() + 5000;
+        while (!heard.includes(message.value) && performance.now() < end) await new Promise(resolve => setTimeout(resolve, 1));
+        channel.post({ kind: "heard", heard });
+    }
+    else if (message.kind === "exit on join") {
+        await join(message.port, { threads: message.threads });
+        exit();
+    }
+
+    else if (message.kind === "host" || message.kind === "host and stall") {
+        const world = createWorld({ [workers]: 0 });
+        void world.share(message.port);
+        hosted = world;
+        // Once the world told the port the lock this thread holds while it lives, where it holds one.
+        await threadLock();
+        channel.post({ kind: "shared" });
+        if (message.kind === "host and stall") Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0);
+    }
+    else if (message.kind === "state" && hosted !== null) {
+        // Once the thread that joined has left.
+        const threads = await until(hosted.threads, shown => shown[0]?.status === "gone");
+        channel.post({
+            kind: "state",
+            driven: message.driven ?? null,
+            total: await Observe.toPromise(Observe.resource(hosted, total)),
+            names: await Observe.toPromise(Observe.resource(hosted, names)),
+            status: threads[0]?.status ?? null,
+        });
+    }
+});

package/src/implementation/world/joining.cases.ts

@@ -0,0 +1,88 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import type * as Fixture from "./joining.fixture.js";
+
+/** Threads joining worlds on others: the cases, over the fixture built for node or from source. */
+export const joiningCases = (load: () => Promise<typeof Fixture>) => describe("joining", () => {
+    const expectDriven = (driven: Awaited<ReturnType<typeof Fixture.worldThere>>["driven"] | null, unimported: RegExp) => {
+        // Runs resolve to what their bodies returned, posted from the world's thread.
+        expect(driven?.runs).toEqual([1, 1, 12, 2, 123]);
+        expect(driven?.failed).toMatch(/^System "fail" \(.*joining\.test-helper\.ts#fail\) failed: joiningTest failure$/);
+        // Its own observer system runs on the joined thread, resolving to what it read there.
+        expect(driven?.read).toBe(123);
+        expect(driven?.total).toBe(123);
+        expect(driven?.selected).toBe(2);
+        expect(driven?.counted).toBe(1);
+        expect(driven?.listed).toEqual([[2, -2], true]);
+        expect(driven?.unimported).toMatch(unimported);
+        expect(driven?.unnamed).toMatch(/has no id, so it can't run from another thread/);
+    };
+
+    it("let a worker join a world here: runs land in call order, observers see the world, and its entity shows its progress", async () => {
+        const fixture = await load();
+        const result = await fixture.worldHere();
+        expectDriven(result.driven, /^System ".*joining-worker\.fixture\.ts#unimportedByMain" isn't one this world imported, so it can't run here\.$/);
+        expect(result.claims).toEqual(["main"]);
+        expect(result.status).toBe("gone");
+        expect(result.total).toBe(123);
+        expect(result.names).toEqual(["a", "b"]);
+    }, 30000);
+
+    it("let this thread join a world on a worker, by the ids of keys and systems both threads imported", async () => {
+        const fixture = await load();
+        const result = await fixture.worldThere();
+        expectDriven(result.driven, /^System ".*joining\.fixture\.ts#unimportedByWorker" isn't one this world imported, so it can't run here\.$/);
+        expect(result.total).toBe(123);
+        expect(result.names).toEqual(["a", "b"]);
+        expect(result.status).toBe("gone");
+    }, 30000);
+
+    it("share a world through a worker's own scope, joined through the worker, the observer factories there giving its values", async () => {
+        const fixture = await load();
+        expect(await fixture.scopes()).toEqual({ observed: 456, total: 456, status: "gone" });
+    }, 30000);
+
+    it("show a joined thread that dies as gone", async () => {
+        const fixture = await load();
+        expect(await fixture.dies()).toEqual({ ran: "ran", share: "joined", status: "gone" });
+    }, 30000);
+
+    it("refuse a thread claimed twice, rejecting its share and its join, saying why", async () => {
+        const fixture = await load();
+        expect(await fixture.claimedTwice()).toEqual({ first: "ran", second: 'Thread "main" is claimed twice.', shared: ["joined", 'Thread "main" is claimed twice.'], status: "gone" });
+    }, 30000);
+
+    it("resolve share once a worker joined, so a run from this thread reaches the observer systems it added as it joined", async () => {
+        const fixture = await load();
+        const result = await fixture.signal();
+        expect(result.share).toBe("joined");
+        expect(result.joined).toBe("joined");
+        expect(result.heard).toContain(7);
+    }, 30000);
+
+    it("reject share for a worker that dies before its join finished, releasing its claims", async () => {
+        const fixture = await load();
+        expect(await fixture.diesJoining()).toEqual({ share: "The thread was gone before it joined.", again: "joined" });
+    }, 30000);
+
+    it("reject a run of an observer system the thread claiming its objects never imported, and go on", async () => {
+        const fixture = await load();
+        expect(await fixture.unimportedObserver()).toEqual({
+            ran: expect.stringMatching(/^System "shelvedHere" runs on thread "main", which the joined thread claiming it never imported\.$/),
+            after: "joined", disposed: "joined",
+        });
+    }, 60000);
+
+    it("reject a share with a worker, and a join through one, that fails as it starts, saying why", async () => {
+        const fixture = await load();
+        expect(await fixture.failingWorkers()).toEqual({
+            shared: expect.stringMatching(/^The thread failed before it joined: .*failing worker$/),
+            joined: expect.stringMatching(/^The world's thread failed before it answered: .*failing worker$/),
+        });
+    }, 60000);
+
+    it("reject a join whose world's thread dies before answering", async () => {
+        const fixture = await load();
+        expect(await fixture.worldDies()).toBe("The world's thread is gone.");
+    }, 30000);
+});

package/src/implementation/world/joining.fixture.ts

@@ -0,0 +1,238 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="node" />
+import { Observe } from "../../observe/index.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 } from "./create.js";
+import type { FromJoiningWorker, ToJoiningWorker } from "./joining-worker.fixture.js";
+import { add, drive, idle, names, shelf, total, until } from "./joining.test-helper.js";
+
+/**
+ * Scenarios of a thread joining a world on another, run built in node and from source in chromium: a worker joining a
+ * world here, this thread joining a world on a worker, a joined worker that dies, and a thread claimed twice.
+ */
+
+/** A system only this thread imports, which a world on a worker never did. */
+const unimportedByWorker = System.create({}, () => {});
+/** An observer system only this thread imports, reading an object of `main`, so it's placed on a thread claiming it. */
+const shelvedHere = System.create({ observer: true }, ({ resources }) => resources[shelf].length);
+
+type Worker = {
+    readonly ask: (message: ToJoiningWorker, transfer?: readonly unknown[]) => Promise<FromJoiningWorker>;
+    readonly terminate: () => Promise<void>;
+    /** The worker itself, as a port to join a world it shares through its scope. */
+    readonly port: Parameters<World["share"]>[0];
+};
+
+/** Whether a reply is the fixture's, not the world's, where it shares the worker's scope. */
+const isReply = (data: unknown): boolean => typeof data === "object" && data !== null && !("protocol" in data);
+
+const workerFile = "./joining-worker.fixture.js";
+
+/** Starts the joining worker, which answers each message with one. */
+const start = (): Worker => {
+    if (typeof globalThis.Worker === "function") {
+        const worker = new globalThis.Worker(new URL("./joining-worker.fixture.js", import.meta.url), { type: "module" });
+        return {
+            ask: (message, transfer = []) => new Promise(resolve => {
+                worker.onmessage = (event: MessageEvent<FromJoiningWorker>) => { if (isReply(event.data)) resolve(event.data); };
+                worker.postMessage(message, { transfer: transfer.filter(port => port instanceof MessagePort) });
+            }),
+            terminate: async () => worker.terminate(),
+            port: worker,
+        };
+    }
+    const threads = globalThis.process.getBuiltinModule("node:worker_threads");
+    const worker = new threads.Worker(new URL(workerFile, import.meta.url));
+    return {
+        ask: (message, transfer = []) => new Promise(resolve => {
+            const reply = (data: FromJoiningWorker): void => {
+                if (!isReply(data)) return;
+                worker.off("message", reply);
+                resolve(data);
+            };
+            worker.on("message", reply);
+            worker.postMessage(message, transfer.filter(port => port instanceof threads.MessagePort));
+        }),
+        terminate: async () => { await worker.terminate(); },
+        port: worker,
+    };
+};
+
+/** Starts a worker that fails as it starts: it, as a port, and how to end it. */
+const startFailing = (): Pick<Worker, "port" | "terminate"> => {
+    if (typeof globalThis.Worker === "function") {
+        const worker = new globalThis.Worker(new URL("./failing-worker.fixture.js", import.meta.url), { type: "module" });
+        return { port: worker, terminate: async () => worker.terminate() };
+    }
+    const threads = globalThis.process.getBuiltinModule("node:worker_threads");
+    const worker = new threads.Worker(new URL("./failing-worker.fixture.js", import.meta.url));
+    return { port: worker, terminate: async () => { await worker.terminate(); } };
+};
+
+const within = <T>(promise: Promise<T>, milliseconds: number, otherwise: T): Promise<T> =>
+    Promise.race([promise, new Promise<T>(resolve => setTimeout(() => resolve(otherwise), milliseconds))]);
+
+/** `"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 here, a worker joining it and driving it, then leaving. */
+export const worldHere = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { port1, port2 } = new MessageChannel();
+    const shared = world.share(port1);
+    const worker = start();
+    const reply = await worker.ask({ kind: "join", port: port2, threads: ["main"] }, [port2]);
+    await shared;
+    const claims = (await until(world.threads, threads => threads[0] !== undefined))[0]?.claims ?? null;
+    const gone = (await until(world.threads, threads => threads[0]?.status === "gone"))[0];
+    const result = {
+        driven: reply.kind === "driven" ? reply.driven : null,
+        claims,
+        status: gone?.status ?? null,
+        total: await Observe.toPromise(Observe.resource(world, total)),
+        names: await Observe.toPromise(Observe.resource(world, names)),
+    };
+    await worker.terminate();
+    await world.dispose();
+    return result;
+};
+
+/** A world on a worker, this thread joining it and driving it, then leaving. */
+export const worldThere = async () => {
+    const worker = start();
+    const { port1, port2 } = new MessageChannel();
+    await worker.ask({ kind: "host", port: port1 }, [port1]);
+    const remote = await join(port2, { threads: ["main"] });
+    const driven = await drive(remote, unimportedByWorker);
+    await remote.dispose();
+    const state = await worker.ask({ kind: "state", driven });
+    await worker.terminate();
+    return state.kind === "state" ? { driven: state.driven, total: state.total, names: state.names, status: state.status } : { driven: null };
+};
+
+/** A worker that joined, then is ended from outside: its status, `"gone"` if the world heard of it. */
+export const dies = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { port1, port2 } = new MessageChannel();
+    const shared = outcomeOf(world.share(port1));
+    const worker = start();
+    const reply = await worker.ask({ kind: "idle", port: port2, threads: [] }, [port2]);
+    const share = await shared;
+    await worker.terminate();
+    const gone = await within(until(world.threads, threads => threads[0]?.status === "gone"), 20000, null);
+    await world.dispose();
+    return { ran: reply.kind === "joined" ? reply.ran : null, share, status: gone?.[0]?.status ?? null };
+};
+
+/** Two workers claiming `main`: each side's outcome of the second's join, the first's run, and the second's status. */
+export const claimedTwice = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const first = new MessageChannel();
+    const second = new MessageChannel();
+    const shares = [outcomeOf(world.share(first.port1)), outcomeOf(world.share(second.port1))];
+    const pair = [start(), start()];
+    const one = await pair[0].ask({ kind: "idle", port: first.port2, threads: ["main"] }, [first.port2]);
+    const two = await pair[1].ask({ kind: "idle", port: second.port2, threads: ["main"] }, [second.port2]);
+    const gone = (await until(world.threads, threads => threads[1]?.status === "gone"))[1];
+    const shared = await Promise.all(shares);
+    for (const worker of pair) await worker.terminate();
+    await world.dispose();
+    return { first: one.kind === "joined" ? one.ran : null, second: two.kind === "joined" ? two.ran : null, shared, status: gone?.status ?? null };
+};
+
+/**
+ * A world here, a worker joining it and adding an observer system as its join resolved: once `share` resolved, a run
+ * from this thread reaches it. What the worker's join and the world's share gave, and what the observer system heard.
+ */
+export const signal = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { port1, port2 } = new MessageChannel();
+    const shared = outcomeOf(world.share(port1));
+    const worker = start();
+    const listening = worker.ask({ kind: "listen", port: port2, threads: ["main"] }, [port2]);
+    const share = await shared;
+    await world.run(add, { amount: 7 });
+    const reply = await listening;
+    const heard = await worker.ask({ kind: "heard", value: 7 });
+    await worker.terminate();
+    await world.dispose();
+    return { share, joined: reply.kind === "listening" ? reply.joined : null, heard: heard.kind === "heard" ? heard.heard : null };
+};
+
+/**
+ * A worker that ends on the turn its join resolved, so the world never hears its join finished: what the world's
+ * share gave, and whether another thread then claims what it claimed.
+ */
+export const diesJoining = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const first = new MessageChannel();
+    const shared = within(outcomeOf(world.share(first.port1)), 20000, "pending");
+    const worker = start();
+    // Never answered: the worker ends.
+    void worker.ask({ kind: "exit on join", port: first.port2, threads: ["main"] }, [first.port2]);
+    const share = await shared;
+    const second = new MessageChannel();
+    const again = outcomeOf(world.share(second.port1));
+    const remote = await join(second.port2, { threads: ["main"] });
+    const result = { share, again: await again };
+    await remote.dispose();
+    await worker.terminate();
+    await world.dispose();
+    return result;
+};
+
+/**
+ * A worker claiming `main`, then a run here of an observer system reading `main`'s objects that the worker never
+ * imported: what the run gave, and whether the world still runs and disposes.
+ */
+export const unimportedObserver = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { port1, port2 } = new MessageChannel();
+    const shared = world.share(port1);
+    const worker = start();
+    await worker.ask({ kind: "idle", port: port2, threads: ["main"] }, [port2]);
+    await shared;
+    const ran = await within(outcomeOf(world.run(shelvedHere)), 10000, "pending");
+    const after = await within(outcomeOf(world.run(idle)), 10000, "pending");
+    const disposed = await within(outcomeOf(world.dispose()), 10000, "pending");
+    await worker.terminate();
+    return { ran, after, disposed };
+};
+
+/** A share with a worker, and a join through another, each failing as it starts: what each gave. */
+export const failingWorkers = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const sharedWith = startFailing();
+    const shared = await within(outcomeOf(world.share(sharedWith.port)), 20000, "pending");
+    const joinedThrough = startFailing();
+    const joined = await within(outcomeOf(join(joinedThrough.port)), 20000, "pending");
+    await sharedWith.terminate();
+    await joinedThrough.terminate();
+    await world.dispose();
+    return { shared, joined };
+};
+
+/** This thread joining a world on a worker that stalls before it answers, then is ended: what the join gave. */
+export const worldDies = async () => {
+    const worker = start();
+    const { port1, port2 } = new MessageChannel();
+    await worker.ask({ kind: "host and stall", port: port1 }, [port1]);
+    const joining = within(outcomeOf(join(port2)), 20000, "pending");
+    await worker.terminate();
+    return await joining;
+};
+
+/** A world on a worker shared through its own scope, this thread joined through the worker: runs, an observer factory, leaving. */
+export const scopes = async () => {
+    const worker = start();
+    await worker.ask({ kind: "host scope" });
+    const remote = await join(worker.port);
+    for (const amount of [4, 5, 6]) await remote.run(add, { amount });
+    const observed = await until(Observe.resource(remote, total), value => value === 456);
+    await remote.dispose();
+    const state = await worker.ask({ kind: "state" });
+    await worker.terminate();
+    return { observed, ...state.kind === "state" ? { total: state.total, status: state.status } : {} };
+};

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

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