@adobe/ecs 0.0.0-stage → 0.2.0

package/src/implementation/world/remote-finalizers.fixture.ts

@@ -0,0 +1,215 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="node" />
+import type { Entity } from "../../interface/entity/entity.js";
+import { Observe } from "../../observe/index.js";
+import { workers } from "../../interface/resources/workers.js";
+import { createWorld, type CreatedWorld } from "./create.js";
+import { indexOf } from "./entities.js";
+import type { FromRemoteFinalizersWorker, ToRemoteFinalizersWorker } from "./remote-finalizers-worker.fixture.js";
+import { despawn, regauge, rehead, released, retitle, scenario, serial, sorted, spawn, spawnHeaded, spawnTitled, type Released, type Surveyed } from "./remote-finalizers.test-helper.js";
+import { runReported } from "./outcomes.test-helper.js";
+
+/**
+ * Scenarios of finalizers on a joined worker, run built in node and from source in chromium: the same stops as an
+ * inline world's, and a worker that never yields holding the indexes of entities it hasn't finalized until it's ended.
+ */
+
+type Worker = { readonly ask: (message: ToRemoteFinalizersWorker, transfer?: readonly unknown[]) => Promise<FromRemoteFinalizersWorker>; readonly terminate: () => Promise<void> };
+
+const workerFile = "./remote-finalizers-worker.fixture.js";
+
+const start = (): Worker => {
+    if (typeof globalThis.Worker === "function") {
+        const worker = new globalThis.Worker(new URL("./remote-finalizers-worker.fixture.js", import.meta.url), { type: "module" });
+        return {
+            ask: (message, transfer = []) => new Promise(resolve => {
+                worker.onmessage = (event: MessageEvent<FromRemoteFinalizersWorker>) => { if (!("protocol" in event.data)) resolve(event.data); };
+                worker.postMessage(message, { transfer: transfer.filter(port => port instanceof MessagePort) });
+            }),
+            terminate: async () => worker.terminate(),
+        };
+    }
+    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: FromRemoteFinalizersWorker): void => {
+                if ("protocol" in 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(); },
+    };
+};
+
+/** The first value an observer gives that `accept` takes. */
+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);
+    });
+});
+
+/** A world shared with a worker that joins it claiming "remoteFinalizersTest", once it joined. */
+const joined = async (world: CreatedWorld): Promise<{ readonly worker: Worker }> => {
+    const { port1, port2 } = new MessageChannel();
+    const shared = world.share(port1);
+    const worker = start();
+    await worker.ask({ kind: "join", port: port2 }, [port2]);
+    await shared;
+    return { worker };
+};
+
+/** Holds the worker, which runs nothing until the returned function lets it go on. */
+const hold = async (worker: Worker): Promise<() => void> => {
+    const flag = new Int32Array(new SharedArrayBuffer(4));
+    await worker.ask({ kind: "hold", flag });
+    return () => {
+        Atomics.store(flag, 0, 1);
+        Atomics.notify(flag, 0);
+    };
+};
+
+/** What the worker's finalizer saw. */
+const releasedThere = async (worker: Worker): Promise<readonly Released[]> => {
+    const reply = await worker.ask({ kind: "released" });
+    return reply.kind === "released" ? reply.released : [];
+};
+
+/** The scenario's stops, inline and with the joined worker running the finalizer, in order by serial. */
+export const sameStops = async () => {
+    released.length = 0;
+    const inline = createWorld({ [workers]: 0 });
+    const counts = await scenario(inline, () => released.length);
+    const expected = sorted(released);
+    await inline.dispose();
+    const world = createWorld({ [workers]: 0 });
+    const { worker } = await joined(world);
+    const seen = await scenario(world, async () => (await releasedThere(worker)).length, counts);
+    const actual = sorted(await releasedThere(worker));
+    await worker.terminate();
+    await world.dispose();
+    return { expected: { counts, stops: expected }, actual: { counts: seen, stops: actual } };
+};
+
+/**
+ * A worker that never yields, so it acknowledges no stop: the indexes of the entities despawned stay held while it
+ * lives, and once it's ended they're reused, the stops it never finalized reported.
+ */
+export const diesHolding = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { worker } = await joined(world);
+    await world.run(spawn, { from: 0, count: 4 });
+    const stopped: Entity[] = [];
+    for (const value of [0, 1, 2]) stopped.push(...await Observe.toPromise(Observe.select(world, { required: [serial], where: { [serial]: value } })));
+    const despawned = new Set(stopped.map(indexOf));
+    /** Live entities at the indexes of those despawned. */
+    const reused = async (): Promise<number> => (await Observe.toPromise(Observe.select(world, { required: [serial] }))).filter(entity => despawned.has(indexOf(entity))).length;
+    await worker.ask({ kind: "spin" });
+    await world.run(despawn, { serials: [0, 1, 2] });
+    // Spawns while it lives take other indexes.
+    await world.run(spawn, { from: 10, count: 6 });
+    const whileHeld = await reused();
+    await worker.terminate();
+    await until(world.threads, threads => threads.at(-1)?.status === "gone");
+    const report = await runReported(world, spawn, { from: 20, count: 0 });
+    await world.run(spawn, { from: 30, count: 6 });
+    const after = await reused();
+    await world.dispose();
+    return { held: despawned.size, whileHeld, failures: report.failures.map(failure => [failure.kind, failure.name, failure.message]), after };
+};
+
+/**
+ * Titled rows despawned while the worker is held, then the world's thread rewriting the titles of others six
+ * times, so the records the despawned rows' titles were in are freed and reused before the worker finalizes them:
+ * the titles its finalizer read.
+ */
+export const titledStops = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { worker } = await joined(world);
+    await world.run(spawnTitled, { from: 0, count: 50 });
+    const release = await hold(worker);
+    try {
+        await world.run(despawn, { serials: Array.from({ length: 50 }, (_, k) => k) });
+        await world.run(spawnTitled, { from: 100, count: 50 });
+        for (let round = 0; round < 6; round++) await world.run(retitle, { round });
+    }
+    finally {
+        release();
+    }
+    let seen: readonly { readonly serial: number; readonly title: string }[] = [];
+    for (let k = 0; k < 200 && seen.length < 50; k++) {
+        const reply = await worker.ask({ kind: "entitled" });
+        seen = reply.kind === "entitled" ? reply.entitled : [];
+    }
+    await worker.terminate();
+    await world.dispose();
+    return [...seen].sort((a, b) => a.serial - b.serial);
+};
+
+/**
+ * Headed rows despawned with the heading "h0" while the worker is held, then the world's thread writing the heading
+ * and subheading six times, so the records of "h0" and "sh0" are freed and reused before the worker finalizes them,
+ * and the rest despawned once it goes on: what its finalizers of one and two string resources read.
+ */
+export const headedStops = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { worker } = await joined(world);
+    await world.run(rehead, { heading: "h0" });
+    await world.run(spawnHeaded, { from: 0, count: 20 });
+    const release = await hold(worker);
+    try {
+        await world.run(despawn, { serials: Array.from({ length: 10 }, (_, k) => k) });
+        for (let round = 1; round <= 6; round++) await world.run(rehead, { heading: `h${round}` });
+    }
+    finally {
+        release();
+    }
+    await world.run(despawn, { serials: Array.from({ length: 10 }, (_, k) => 10 + k) });
+    let seen: readonly { readonly serial: number; readonly heading: string }[] = [];
+    let both: readonly { readonly serial: number; readonly heading: string; readonly subheading: string }[] = [];
+    for (let k = 0; k < 200 && (seen.length < 20 || both.length < 20); k++) {
+        const reply = await worker.ask({ kind: "headlined" });
+        seen = reply.kind === "headlined" ? reply.headlined : [];
+        both = reply.kind === "headlined" ? reply.both : [];
+    }
+    await worker.terminate();
+    await world.dispose();
+    return { one: [...seen].sort((a, b) => a.serial - b.serial), two: [...both].sort((a, b) => a.serial - b.serial) };
+};
+
+/**
+ * Headed rows despawned at level 0 while the worker is held, then the world's thread writing the level and origin six
+ * times, with resources of mixed widths, and the rest despawned once it goes on: what its finalizers read.
+ */
+export const gaugedStops = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { worker } = await joined(world);
+    await world.run(regauge, { level: 0 });
+    await world.run(spawnHeaded, { from: 0, count: 20 });
+    const release = await hold(worker);
+    try {
+        await world.run(despawn, { serials: Array.from({ length: 10 }, (_, k) => k) });
+        for (let round = 1; round <= 6; round++) await world.run(regauge, { level: round });
+    }
+    finally {
+        release();
+    }
+    await world.run(despawn, { serials: Array.from({ length: 10 }, (_, k) => 10 + k) });
+    let seen: readonly { readonly serial: number; readonly level: number; readonly origin: readonly number[] }[] = [];
+    let mixed: readonly Surveyed[] = [];
+    for (let k = 0; k < 200 && (seen.length < 20 || mixed.length < 20); k++) {
+        const reply = await worker.ask({ kind: "gauged" });
+        seen = reply.kind === "gauged" ? reply.gauged : [];
+        mixed = reply.kind === "gauged" ? reply.surveyed : [];
+    }
+    await worker.terminate();
+    await world.dispose();
+    return { linear: [...seen].sort((a, b) => a.serial - b.serial), mixed: [...mixed].sort((a, b) => a.serial - b.serial) };
+};

package/src/implementation/world/remote-finalizers.test-helper.ts

@@ -0,0 +1,252 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Entity } from "../../interface/entity/entity.js";
+import { Finalizer } from "../../interface/finalizer/finalizer.js";
+import { System } from "../../interface/system/system.js";
+import type { World } from "../../interface/world/world.js";
+import type { Schema } from "../../interface/schema/schema.js";
+import type { Vec3 } from "../../interface/math/index.js";
+
+// Keys, systems and a finalizer both threads of the remote finalizers tests import: a finalizer on thread
+// "remoteFinalizersTest", which a joined thread fills, reading structs, a constant, that thread's objects and its
+// object resource, and what it saw, on the thread it ran on.
+
+export const serial = Symbol("remoteFinalizersTest/serial");
+export const place = Symbol("remoteFinalizersTest/place");
+export const marked = Symbol("remoteFinalizersTest/marked");
+export const flagged = Symbol("remoteFinalizersTest/flagged");
+export const widget = Symbol("remoteFinalizersTest/widget");
+export const label = Symbol("remoteFinalizersTest/label");
+export const tone = Symbol("remoteFinalizersTest/tone");
+export const title = Symbol("remoteFinalizersTest/title");
+export const headed = Symbol("remoteFinalizersTest/headed");
+export const heading = Symbol("remoteFinalizersTest/heading");
+export const subheading = Symbol("remoteFinalizersTest/subheading");
+export const level = Symbol("remoteFinalizersTest/level");
+export const origin = Symbol("remoteFinalizersTest/origin");
+export const caption = Symbol("remoteFinalizersTest/caption");
+export const lit = Symbol("remoteFinalizersTest/lit");
+export const tint = Symbol("remoteFinalizersTest/tint");
+export const sample = Symbol("remoteFinalizersTest/sample");
+export const material = Symbol("remoteFinalizersTest/material");
+declare module "@adobe/ecs" {
+    export interface Threads {
+        remoteFinalizersTest: true;
+    }
+    export interface Components {
+        [serial]: { type: Schema.Type<{ type: "integer" }> };
+        [place]: { type: readonly [number, number] };
+        [marked]: { type: true };
+        [flagged]: { type: true };
+        [widget]: { type: Widget | null; thread: "remoteFinalizersTest" };
+        [label]: { type: { readonly text: string } | null; thread: "remoteFinalizersTest"; default: { text: "none" } };
+        [title]: { type: string };
+        [headed]: { type: true };
+    }
+    export interface Resources {
+        [tone]: { type: { readonly text: string }; thread: "remoteFinalizersTest"; default: { text: "quiet" } };
+        [heading]: { type: string; default: "h" };
+        [subheading]: { type: string; default: "s" };
+        [level]: { type: number; default: -1 };
+        [origin]: { type: readonly [number, number]; default: [-1, -1] };
+        [caption]: { type: string; default: "c" };
+        [lit]: { type: boolean };
+        [tint]: { type: Vec3; default: [-1, -1, -1] };
+        [sample]: { type: Schema.Type<{ type: "object"; properties: { on: { type: "boolean" }; count: { type: "integer"; minimum: 0; maximum: 4294967295 }; weight: { type: "number" }; ratio: { type: "number"; precision: 1 } } }>; default: { on: false; count: 0; weight: -1; ratio: -1 } };
+        [material]: { type: Schema.Type<{ type: "object"; properties: { alpha: { type: "number"; precision: 1 }; color: { type: "array"; items: { type: "number"; precision: 1 }; minItems: 3; maxItems: 3 }; glossy: { type: "boolean" } }; layout: "storage" }>; default: { alpha: -1; color: [-1, -1, -1]; glossy: false } };
+    }
+}
+/** A value that isn't data, which only its thread holds. */
+type Widget = { readonly tag: string; readonly draw: () => string };
+const text = { type: "object", properties: { text: { type: "string" } } } as const;
+/** A string, in shared memory, which the world's thread writes and the finalizer on the thread reads. */
+/** A string resource, which the world's thread writes and the finalizer on the thread reads. */
+/** Linear resources, a number and a struct, which the world's thread writes and the finalizer on the thread reads. */
+/** Resources of mixed widths: a string, a boolean (1 byte), an f32 vec3 (12), a padded CPU struct (24) and a storage struct (32). */
+type Sample = { readonly on: boolean; readonly count: number; readonly weight: number; readonly ratio: number };
+type Material = { readonly alpha: number; readonly color: readonly [number, number, number]; readonly glossy: boolean };
+const f32 = { type: "number", precision: 1 } as const;
+const vec3 = { type: "array", items: f32, minItems: 3, maxItems: 3 } as const;
+
+/** A stop as the finalizer saw it, on the thread it ran on. */
+export type Released = { readonly serial: number; readonly place: readonly number[]; readonly marked: boolean; readonly widget: string | null; readonly label: string | null; readonly tone: string };
+
+/** Every stop finalized on this thread, in order, with the entity each was. */
+export const released: Released[] = [];
+export const finalized: Entity[] = [];
+/** Serials whose stops throw. */
+export const throwing = new Set<number>();
+
+/** On the finalizers' thread: what each stop held there, its structs before the sync point applied. */
+export const release = Finalizer.create({ components: { with: [serial, place, marked, widget, label] } }, (row, { resources }) => {
+    finalized.push(row.entity);
+    released.push({ serial: row[serial], place: [...row[place]], marked: row[marked], widget: row[widget]?.tag ?? null, label: row[label]?.text ?? null, tone: resources[tone].text });
+    if (throwing.has(row[serial])) throw new Error(`remoteFinalizersTest: ${row[serial]} throws`);
+});
+
+/** Every titled stop finalized on this thread, in order, with the title it read. */
+export const entitled: { readonly serial: number; readonly title: string }[] = [];
+
+/** On the finalizers' thread: what each titled stop's title was before its sync point applied. */
+export const entitle = Finalizer.create({ components: { with: [serial, title, widget] } }, row => {
+    // Reading its widget places it on the widget's thread.
+    void row[widget];
+    entitled.push({ serial: row[serial], title: row[title] });
+});
+
+/** Every headed stop finalized on this thread, in order, with the heading it read. */
+export const headlined: { readonly serial: number; readonly heading: string }[] = [];
+
+/** On the finalizers' thread: the heading as it was before each headed stop's sync point applied. */
+export const headline = Finalizer.create({ components: { with: [serial, widget, headed] } }, (row, { resources }) => {
+    void row[widget];
+    headlined.push({ serial: row[serial], heading: resources[heading] });
+});
+
+/** Every headed stop finalized on this thread, in order, with the heading and subheading it read. */
+export const headlinedBoth: { readonly serial: number; readonly heading: string; readonly subheading: string }[] = [];
+
+/** On the finalizers' thread: two string resources as they were before each headed stop's sync point applied. */
+export const headlines = Finalizer.create({ components: { with: [serial, widget, headed] } }, (row, { resources }) => {
+    void row[widget];
+    headlinedBoth.push({ serial: row[serial], heading: resources[heading], subheading: resources[subheading] });
+});
+
+/** Every headed stop finalized on this thread, in order, with the linear resources it read. */
+export const gauged: { readonly serial: number; readonly level: number; readonly origin: readonly number[] }[] = [];
+
+/** On the finalizers' thread: a number and a struct resource as they were before each headed stop's sync point applied. */
+export const gauge = Finalizer.create({ components: { with: [serial, widget, headed] } }, (row, { resources }) => {
+    void row[widget];
+    gauged.push({ serial: row[serial], level: resources[level], origin: [...resources[origin]] });
+});
+
+/** Every headed stop finalized on this thread, in order, with the resources of mixed widths it read. */
+export type Surveyed = { readonly serial: number; readonly caption: string; readonly lit: boolean; readonly tint: readonly number[]; readonly sample: Sample; readonly material: Material };
+export const surveyed: Surveyed[] = [];
+
+/** On the finalizers' thread: resources of mixed widths as they were before each headed stop's sync point applied. */
+export const survey = Finalizer.create({ components: { with: [serial, widget, headed] } }, (row, { resources }) => {
+    void row[widget];
+    const { alpha, color, glossy } = resources[material];
+    surveyed.push({
+        serial: row[serial], caption: resources[caption], lit: resources[lit], tint: [...resources[tint]],
+        sample: { ...resources[sample] }, material: { alpha, color: [...color], glossy },
+    });
+});
+
+/** What `regauge` writes to the resources of mixed widths at a level. */
+export const surveyOf = (at: number): Omit<Surveyed, "serial"> => ({
+    caption: `c${at}`, lit: at > 3, tint: [at, at + 0.5, at * 2],
+    sample: { on: at > 3, count: at * 1000 + 1, weight: at + 0.25, ratio: at * 0.5 + 1 },
+    material: { alpha: at * 0.25 + 1, color: [at + 1, at + 2, at + 3], glossy: at > 3 },
+});
+
+/** From the world's thread: the level, the origin at it, and the resources of mixed widths at it. */
+export const regauge = System.create({}, ({ resources }, input: { readonly level: number }) => {
+    resources[level] = input.level;
+    resources[origin] = [input.level, input.level + 10];
+    const values = surveyOf(input.level);
+    resources[caption] = values.caption;
+    resources[lit] = values.lit;
+    resources[tint] = [values.tint[0], values.tint[1], values.tint[2]];
+    resources[sample] = values.sample;
+    resources[material] = values.material;
+});
+
+/** Spawns headed rows from the world's thread, with the thread's widget at null. */
+export const spawnHeaded = System.create({}, ({ commands }, input: { readonly from: number; readonly count: number }) => {
+    for (let k = input.from; k < input.from + input.count; k++) commands.spawn([serial, headed, widget])({ [serial]: k, [widget]: null });
+});
+/** From the world's thread: the heading and subheading. */
+export const rehead = System.create({}, ({ resources }, input: { readonly heading: string }) => {
+    resources[heading] = input.heading;
+    resources[subheading] = `s${input.heading}`;
+});
+
+/** Spawns titled rows from the world's thread, with the thread's widget at null. */
+export const spawnTitled = System.create({}, ({ commands }, input: { readonly from: number; readonly count: number }) => {
+    for (let k = input.from; k < input.from + input.count; k++) commands.spawn([serial, title, widget])({ [serial]: k, [title]: `t${k}`, [widget]: null });
+});
+/** From the world's thread: every title as another of the same size, so the records of titles let go are reused. */
+export const retitle = System.create({ components: { with: [title] } }, (row, _context, input: { readonly round: number }) => {
+    row[title] = `r${input.round}`;
+});
+
+/** Spawns from the world's thread: structs, the thread's objects at null and their start. */
+export const spawn = System.create({}, ({ commands }, input: { readonly from: number; readonly count: number }) => {
+    for (let k = input.from; k < input.from + input.count; k++) commands.spawn([serial, place, marked, widget, label])({ [serial]: k, [place]: [k, -k], [widget]: null });
+});
+/** On the thread: widgets written in place. */
+export const attach = System.create({ components: { with: [serial, widget] } }, row => {
+    const tag = `w${row[serial]}`;
+    row[widget] = { tag, draw: () => tag };
+});
+/** On the thread: labels given by command, staged there, for odd serials. */
+export const relabel = System.create({ components: { with: [serial, label] } }, (row, { commands }) => {
+    const relabelled = { text: `l${row[serial]}${row[label]?.text === "none" ? "" : "+"}` };
+    if (row[serial] % 2 === 1) commands.add(row.entity, label, relabelled);
+});
+/** On the thread: its object resource. */
+export const retone = System.create({}, ({ resources }, input: { readonly tone: string }) => {
+    resources[tone] = { text: input.tone };
+});
+/** From the world's thread: places move, so a stop's values are those before the sync point applies. */
+export const shift = System.create({ components: { with: [place] } }, row => {
+    row[place] = [row[place][0] + 100, row[place][1]];
+});
+/** From the world's thread: despawns these serials. */
+export const despawn = System.create({ components: { with: [serial] } }, (row, { commands }, input: { readonly serials: readonly number[] }) => {
+    if (input.serials.includes(row[serial])) commands.despawn(row.entity);
+});
+/** From the world's thread: removes widgets of these serials, a stop that despawns nothing. */
+export const strip = System.create({ components: { with: [serial, widget] } }, (row, { commands }, input: { readonly serials: readonly number[] }) => {
+    if (input.serials.includes(row[serial])) commands.remove(row.entity, widget);
+});
+/** From the world's thread: every row moves archetype, flagged on one run and not on the next. */
+export const flag = System.create({ components: { with: [serial], not: [flagged] } }, (row, { commands }) => {
+    commands.add(row.entity, flagged);
+});
+export const unflag = System.create({ components: { with: [serial, flagged] } }, (row, { commands }) => {
+    commands.remove(row.entity, flagged);
+});
+
+/** Waits until `done` holds, letting other tasks run, for at most `milliseconds`. */
+export const eventually = async (done: () => boolean | Promise<boolean>, milliseconds = 20000): Promise<boolean> => {
+    const deadline = performance.now() + milliseconds;
+    while (!await done() && performance.now() < deadline) await new Promise(resolve => setTimeout(resolve, 1));
+    return done();
+};
+
+/** Stops in a comparable order: by serial, then as they came. */
+export const sorted = (stops: readonly Released[]): readonly Released[] => stops.map((stop, k) => [stop, k] as const).sort((a, b) => a[0].serial - b[0].serial || a[1] - b[1]).map(([stop]) => stop);
+
+/**
+ * The runs both worlds take: spawns, widgets and labels given on the finalizers' thread, despawns and a removal in
+ * sync points that move other rows into the stopped ones, a crowd moved past what a joined thread's log holds before
+ * its despawns, and its object resource changed. `stops` is how many stops the finalizer has seen, wherever it runs;
+ * each step waits until it saw `expected` of them, with what an inline world saw first.
+ */
+export const scenario = async (world: World, stops: () => number | Promise<number>, expected: readonly number[] = []): Promise<readonly number[]> => {
+    const seen: number[] = [];
+    const step = async (run: Promise<unknown>): Promise<void> => {
+        await run;
+        const wanted = expected[seen.length];
+        if (wanted !== undefined) await eventually(async () => await stops() >= wanted);
+        seen.push(await stops());
+    };
+    await step(world.run(spawn, { from: 0, count: 12 }));
+    await step(world.run(attach));
+    await step(world.run(relabel));
+    await step(world.run(shift));
+    await step(world.run(despawn, { serials: [1, 2, 5, 11] }));
+    await step(world.run(strip, { serials: [3] }));
+    await step(world.run(retone, { tone: "loud" }));
+    await step(world.run(despawn, { serials: [3, 4] }));
+    await step(world.run(spawn, { from: 100, count: 300 }));
+    await step(world.run(attach));
+    await step(world.run(relabel));
+    for (let k = 0; k < 30; k++) await step(world.run(k % 2 === 0 ? flag : unflag));
+    await step(world.run(despawn, { serials: [100, 101, 150, 299] }));
+    await step(world.run(despawn, { serials: [6, 7] }));
+    return seen;
+};