@adobe/ecs 0.0.0-stage → 0.1.0

package/src/implementation/world/stop-lists.ts

@@ -0,0 +1,308 @@
+import type { Finalizer } from '../../interface/finalizer/created.js';
+import type { Memory } from './memory.js';
+import type { StringStore } from './strings.js';
+import { logFinalizedWord, logStopsWord, type MoveLog } from './move-log.js';
+
+// Stop lists (threads.md, "Finalizers on other threads"): what a joined thread's finalizers need of the entities a sync
+// point stops, written by the world's thread before it applies, one block per sync point with stops, which the thread
+// reads as it replays that sync and acknowledges by the sync it finalized through.
+//
+// A block's words: its sync, modulo 2^32; the next block's offset, stored once it's written, 0 until then; its groups;
+// its bytes. Then a group per finalizer with stops, in the world's finalizer order: its index on the thread, its stops,
+// its bytes; then as columns, each on 8 bytes, every stop's entity (f64), its archetype and row before apply (u32), the
+// tag of each object it reads (u32), and the value of each linear struct it reads in that component's layout, or for a
+// string, the handle of a copy of its record, freed with the block, since the thread may read it sync points later.
+
+export const blockSyncWord = 0;
+export const blockNextWord = 1;
+export const blockGroupsWord = 2;
+export const blockBytesWord = 3;
+export const blockHeaderBytes = 16;
+export const groupIndexWord = 0;
+export const groupCountWord = 1;
+export const groupBytesWord = 2;
+export const groupHeaderBytes = 16;
+
+const align = (bytes: number): number => (bytes + 7) & ~7;
+
+/** Where a group of `count` stops keeps its entities, archetypes and rows, past its header. */
+export const entitiesAt = (group: number): number => group + groupHeaderBytes;
+export const archetypesAt = (group: number, count: number): number => group + groupHeaderBytes + 8 * count;
+export const rowsAt = (group: number, count: number): number => group + groupHeaderBytes + 12 * count;
+/** Where a group's tags of its `object`th object read start. */
+export const tagsAt = (group: number, count: number, object: number): number => group + groupHeaderBytes + 16 * count + object * align(4 * count);
+/** Where a group's linear values start, after the tags of its `objects` object reads. */
+export const valuesAt = (group: number, count: number, objects: number): number => tagsAt(group, count, objects);
+/** Bytes of one linear read's column of `count` values of `stride` bytes. */
+export const columnBytes = (count: number, stride: number): number => align(count * stride);
+
+/** Bytes of a group of `count` stops of a finalizer reading `objects` objects and linear values of `strides` bytes. */
+const groupBytes = (count: number, objects: number, strides: readonly number[]): number => {
+    let bytes = valuesAt(0, count, objects);
+    for (const stride of strides) bytes += columnBytes(count, stride);
+    return bytes;
+};
+
+/** One of a joined thread's finalizers, as the world writes its stops. */
+export type StopsOf = {
+    readonly finalizer: Finalizer;
+    /** Its index on the thread. */
+    readonly index: number;
+    /** The components of its object reads, then of its linear reads with their strides, in its `read` order. */
+    readonly objects: readonly number[];
+    readonly linear: readonly number[];
+    readonly strides: readonly number[];
+    /** By linear read: whether it's a string's handles, whose records the block holds copies of. */
+    readonly copies: readonly boolean[];
+    /** This sync point's stops, as plan entries, reused by every sync point. */
+    readonly entries: number[];
+};
+
+/** A block the thread hasn't acknowledged, or the newest it has, which it still reads the next block's offset from. */
+type Written = {
+    readonly offset: number;
+    readonly bytes: number;
+    readonly sync: number;
+    /** Indexes of despawned entities, held until the thread acknowledges. */
+    readonly held: number[];
+    /** Its finalizers and their stops, reported if the thread is gone before it acknowledges. */
+    readonly stopped: readonly (readonly [Finalizer, number])[];
+    /** The copies of strings' records its stops hold, let go once the thread acknowledges. */
+    readonly strings: number[];
+    acknowledged: boolean;
+};
+
+/** The world's end of a joined thread's stop lists. */
+export type StopWriter = {
+    readonly memory: Memory;
+    readonly log: MoveLog;
+    /** The world's records of strings, which stops copy. */
+    readonly strings: StringStore | null;
+    /** Finalizers with stops this sync point, in order, whose block is written once every finalizer ran. */
+    readonly staged: StopsOf[];
+    readonly written: Written[];
+    /** Whether a block was written since the thread was last woken. */
+    unwoken: boolean;
+};
+
+export const createStopWriter = (memory: Memory, log: MoveLog, strings: StringStore | null): StopWriter => ({ memory, log, strings, staged: [], written: [], unwoken: false });
+
+/**
+ * Indexes of entities despawned with stops of joined threads' finalizers: by index, how many threads haven't
+ * acknowledged the stop, so the sync point kills them without releasing them; and how many are held.
+ */
+export type Holds = { counts: Int32Array; size: number };
+
+export const createHolds = (): Holds => ({ counts: new Int32Array(0), size: 0 });
+
+const hold = (holds: Holds, index: number): void => {
+    if (index >= holds.counts.length) {
+        const counts = new Int32Array(Math.max(index + 1, 2 * holds.counts.length, 1024));
+        counts.set(holds.counts);
+        holds.counts = counts;
+    }
+    if (holds.counts[index]++ === 0) holds.size++;
+};
+
+/**
+ * Writes the handles of copies of a string's records at word `at`, for a group's `count` stops at the archetypes and
+ * rows its words there name, keeping each copy in `copied`. Copying may grow the memory, which leaves `u32` over the
+ * block as it was: it's shared.
+ */
+const copyStrings = (strings: StringStore, copied: number[], u32: Uint32Array, at: number, count: number, archetypeWords: number, rowWords: number, id: number, archetypes: StopSource["archetypes"]): void => {
+    let archetype = -1;
+    let handles: Uint32Array | undefined;
+    for (let i = 0; i < count; i++) {
+        if (u32[archetypeWords + i] !== archetype) {
+            archetype = u32[archetypeWords + i];
+            handles = archetypes[archetype].storageById[id]?.views.u32;
+        }
+        if (handles === undefined) continue;
+        const copy = strings.copy(handles[u32[rowWords + i]]);
+        copied.push(copy);
+        u32[at + i] = copy;
+    }
+};
+
+/** A storage as stops are copied from it: its tags, or its linear values. */
+type Copied = { readonly tags: Uint32Array; readonly views: { readonly u8: Uint8Array; readonly u32: Uint32Array } };
+
+/** What a sync point's stops come from: entries' entities and archetypes before apply, and the entity table's rows. */
+export type StopSource = {
+    readonly entity: Float64Array;
+    readonly from: Int32Array;
+    readonly despawned: Uint8Array;
+    readonly archetypes: readonly { readonly storageById: readonly (Copied | undefined)[] }[];
+    readonly row: Uint32Array;
+    readonly holds: Holds;
+};
+
+/**
+ * Writes the block of a sync point's staged stops, before it applies: entities, archetypes and rows, tags and linear
+ * values, copied from the rows they're at, a column at a time; despawned entities' indexes held. Links it after the
+ * last block.
+ */
+export const writeStops = (writer: StopWriter, sync: number, source: StopSource): void => {
+    const { staged, memory } = writer;
+    if (staged.length === 0) return;
+    let bytes = blockHeaderBytes;
+    for (const stops of staged) bytes += groupBytes(stops.entries.length, stops.objects.length, stops.strides);
+    const offset = memory.allocate(bytes);
+    const buffer = memory.memory.buffer;
+    const u8 = new Uint8Array(buffer);
+    const u32 = new Uint32Array(buffer);
+    const f64 = new Float64Array(buffer);
+    const held: number[] = [];
+    const stopped: (readonly [Finalizer, number])[] = [];
+    const copied: number[] = [];
+    u32[(offset >> 2) + blockSyncWord] = sync >>> 0;
+    u32[(offset >> 2) + blockNextWord] = 0;
+    u32[(offset >> 2) + blockGroupsWord] = staged.length;
+    u32[(offset >> 2) + blockBytesWord] = bytes;
+    let group = offset + blockHeaderBytes;
+    const { entity, from, despawned, archetypes, row: rows, holds } = source;
+    for (const stops of staged) {
+        const { entries, objects, linear, strides, copies } = stops;
+        const count = entries.length;
+        const size = groupBytes(count, objects.length, strides);
+        u32[(group >> 2) + groupIndexWord] = stops.index;
+        u32[(group >> 2) + groupCountWord] = count;
+        u32[(group >> 2) + groupBytesWord] = size;
+        const entityWords = entitiesAt(group) >> 3;
+        const archetypeWords = archetypesAt(group, count) >> 2;
+        const rowWords = rowsAt(group, count) >> 2;
+        for (let i = 0; i < count; i++) {
+            const entry = entries[i];
+            const stoppedEntity = entity[entry];
+            const index = stoppedEntity >>> 0;
+            f64[entityWords + i] = stoppedEntity;
+            u32[archetypeWords + i] = from[entry];
+            u32[rowWords + i] = rows[index];
+            if (despawned[entry] === 1) {
+                hold(holds, index);
+                held.push(index);
+            }
+        }
+        for (let k = 0; k < objects.length; k++) {
+            const tagWords = tagsAt(group, count, k) >> 2;
+            const id = objects[k];
+            let archetype = -1;
+            let tags: Uint32Array | undefined;
+            for (let i = 0; i < count; i++) {
+                if (u32[archetypeWords + i] !== archetype) {
+                    archetype = u32[archetypeWords + i];
+                    tags = archetypes[archetype].storageById[id]?.tags;
+                }
+                u32[tagWords + i] = tags?.[u32[rowWords + i]] ?? 0;
+            }
+        }
+        let column = valuesAt(group, count, objects.length);
+        for (let k = 0; k < linear.length; k++) {
+            const stride = strides[k];
+            const id = linear[k];
+            const words = (stride & 3) === 0 ? stride >> 2 : 0;
+            let archetype = -1;
+            let values: Copied["views"] | undefined;
+            if (copies[k] && writer.strings !== null) {
+                copyStrings(writer.strings, copied, u32, column >> 2, count, archetypeWords, rowWords, id, archetypes);
+                column += columnBytes(count, stride);
+                continue;
+            }
+            for (let i = 0; i < count; i++) {
+                if (u32[archetypeWords + i] !== archetype) {
+                    archetype = u32[archetypeWords + i];
+                    values = archetypes[archetype].storageById[id]?.views;
+                }
+                if (values === undefined) continue;
+                const row = u32[rowWords + i];
+                if (words > 0) {
+                    const source = values.u32;
+                    const target = (column >> 2) + i * words;
+                    for (let w = 0; w < words; w++) u32[target + w] = source[row * words + w];
+                }
+                else {
+                    const source = values.u8;
+                    const target = column + i * stride;
+                    for (let b = 0; b < stride; b++) u8[target + b] = source[row * stride + b];
+                }
+            }
+            column += columnBytes(count, stride);
+        }
+        stopped.push([stops.finalizer, count]);
+        group += size;
+        entries.length = 0;
+    }
+    staged.length = 0;
+    const last = writer.written.at(-1);
+    // Stored last, so the thread reads the block only once it's whole.
+    if (last === undefined) Atomics.store(writer.log.header, logStopsWord, offset);
+    else Atomics.store(u32, (last.offset >> 2) + blockNextWord, offset);
+    writer.written.push({ offset, bytes, sync: sync >>> 0, held, stopped, strings: copied, acknowledged: false });
+    writer.unwoken = true;
+};
+
+/** Lets go of the copies of strings' records a block's stops hold. */
+const letGo = (writer: StopWriter, block: Written): void => {
+    const { strings } = writer;
+    if (strings !== null) for (let k = 0; k < block.strings.length; k++) strings.retire(block.strings[k]);
+    block.strings.length = 0;
+};
+
+/** Returns a held index once no thread finalizes it any more: it's reusable after the sync point. */
+const unhold = (holds: Holds, released: number[], held: readonly number[]): void => {
+    const { counts } = holds;
+    for (const index of held) {
+        if (--counts[index] !== 0) continue;
+        holds.size--;
+        released.push(index);
+    }
+};
+
+/**
+ * Takes up what the thread acknowledged: blocks through the sync it finalized through return their held indexes, and
+ * all but the newest of them are freed, since the thread reads the next block's offset from that one.
+ */
+export const settleStops = (writer: StopWriter, holds: Holds, released: number[]): void => {
+    const { written, memory } = writer;
+    if (written.length === 0) return;
+    const finalized = Atomics.load(writer.log.header, logFinalizedWord) >>> 0;
+    let newest = -1;
+    for (let k = 0; k < written.length; k++) {
+        const block = written[k];
+        if (((finalized - block.sync) | 0) < 0) break;
+        if (!block.acknowledged) {
+            block.acknowledged = true;
+            unhold(holds, released, block.held);
+            letGo(writer, block);
+        }
+        newest = k;
+    }
+    for (let k = 0; k < newest; k++) memory.free(written[k].offset, written[k].bytes);
+    if (newest > 0) written.splice(0, newest);
+};
+
+/**
+ * Once the thread is gone: every held index returns, and each finalizer with stops it never acknowledged is a `"thread"`
+ * failure, for the next sync point's report.
+ */
+export const endStops = (writer: StopWriter, holds: Holds, released: number[], label: string): { readonly finalizer: Finalizer; readonly error: Error; readonly kind: "thread" }[] => {
+    settleStops(writer, holds, released);
+    const missed = new Map<Finalizer, number>();
+    for (const block of writer.written) {
+        if (block.acknowledged) continue;
+        block.acknowledged = true;
+        unhold(holds, released, block.held);
+        letGo(writer, block);
+        for (const [finalizer, count] of block.stopped) missed.set(finalizer, (missed.get(finalizer) ?? 0) + count);
+    }
+    return [...missed].map(([finalizer, count]) => ({
+        finalizer, kind: "thread",
+        error: new Error(`Thread "${label}" is gone, so ${count === 1 ? "a stop" : `${count} stops`} of finalizer "${finalizer.name}" didn't run there.`),
+    }));
+};
+
+/** Frees every block once the thread left: one that died may still be reading them. */
+export const freeStops = (writer: StopWriter): void => {
+    for (const block of writer.written) writer.memory.free(block.offset, block.bytes);
+    writer.written.length = 0;
+};

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

@@ -0,0 +1,200 @@
+import { afterEach, 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 { createWorld, join } from "./create.js";
+import { readEach, readResource, select } from "./reads.test-helper.js";
+import { fillReports } from "./reports.test-helper.js";
+
+const label = Symbol("stringsTest/label");
+const order = Symbol("stringsTest/order");
+const tagged = Symbol("stringsTest/tagged");
+const mode = Symbol("stringsTest/mode");
+const title = Symbol("stringsTest/title");
+const note = Symbol("stringsTest/note");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [label]: { type: string };
+        [order]: { type: number };
+        [tagged]: { type: true };
+        [note]: { type: string | null };
+    }
+    export interface Resources {
+        [mode]: { type: "edit" | "view" };
+        [title]: { type: string };
+    }
+}
+
+Component.register(label, { type: { type: "string" } });
+Component.register(order, { type: { type: "number" } });
+Component.register(tagged, { type: { const: true } });
+Component.register(note, { type: { anyOf: [{ type: "string" }, { type: "null" }] } });
+Resource.register(mode, { type: { anyOf: [{ const: "edit" }, { const: "view" }], default: "view" } });
+Resource.register(title, { type: { type: "string", default: "" } });
+
+/** Text of every kind a string holds: none, letters, astral characters as surrogate pairs, and a long run. */
+const textOf = (n: number): string => n % 4 === 0 ? "" : n % 4 === 1 ? `item ${n}` : n % 4 === 2 ? `✓ ${n} 😀 naïve` : `${"long ".repeat(40)}${n}`;
+
+const spawn = System.create({ name: "stringsTest/spawn", input: { type: "object", properties: { count: { type: "integer" }, from: { type: "integer" } } } }, ({ input, commands }) => {
+    for (let i = 0; i < input.count; i++) commands.spawn([label, order])({ [label]: textOf(input.from + i), [order]: input.from + i });
+});
+
+/** `count` rows with labels of 400 code units, whose records are 1024-byte blocks of the arena. */
+const spawnLong = System.create({ name: "stringsTest/spawnLong", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+    for (let i = 0; i < input.count; i++) commands.spawn([label, order])({ [label]: `${i}`.padStart(400, "·"), [order]: i });
+});
+
+/** A run over every row that changes nothing, for its sync point. */
+const pass = System.create({ name: "stringsTest/pass", components: { read: [order] } }, row => { void row[order]; });
+
+const rename = System.create({ name: "stringsTest/rename", input: { type: "object", properties: { suffix: { type: "string" } } }, components: { read: [order], write: [label] } }, (row, { input }) => {
+    row[label] = `${textOf(row[order])}${input.suffix}`;
+});
+
+const relabel = System.create({ name: "stringsTest/relabel", input: { type: "object", properties: { suffix: { type: "string" } } }, components: { read: [order], has: [label] } }, (row, { input, commands }) => {
+    commands.add(row.entity, label, `${textOf(row[order])}${input.suffix}`);
+});
+
+const tag = System.create({ name: "stringsTest/tag", components: { has: [label] } }, (row, { commands }) => commands.add(row.entity, tagged));
+const untag = System.create({ name: "stringsTest/untag", components: { has: [tagged] } }, (row, { commands }) => commands.remove(row.entity, tagged));
+const unlabel = System.create({ name: "stringsTest/unlabel", components: { has: [label] } }, (row, { commands }) => commands.remove(row.entity, label));
+const despawn = System.create({ name: "stringsTest/despawn", components: { has: [order] } }, (row, { commands }) => commands.despawn(row.entity));
+const annotate = System.create({ name: "stringsTest/annotate", components: { read: [order], write: [note] } }, row => {
+    row[note] = row[order] % 3 === 0 ? null : `note ${row[order]}`;
+});
+const unannotate = System.create({ name: "stringsTest/unannotate", components: { write: [note] } }, row => {
+    row[note] = null;
+});
+const noted = System.create({ name: "stringsTest/noted", components: { has: [order], not: [note] } }, (row, { commands }) => commands.add(row.entity, note, null));
+const despawnEven = System.create({ name: "stringsTest/despawnEven", components: { read: [order] } }, (row, { commands }) => {
+    if (row[order] % 2 === 0) commands.despawn(row.entity);
+});
+const labelAgain = System.create({ name: "stringsTest/labelAgain", input: { type: "object", properties: { suffix: { type: "string" } } }, components: { read: [order], not: [label] } }, (row, { input, commands }) => {
+    commands.add(row.entity, label, `${textOf(row[order])}${input.suffix}`);
+});
+
+const edit = System.create({ name: "stringsTest/edit", input: { type: "object", properties: { title: { type: "string" } } }, resources: { write: [mode, title] } }, ({ input, resources }) => {
+    resources[mode] = "edit";
+    resources[title] = input.title;
+});
+
+/** Each entity's label, in order. */
+const labels = async (world: ReturnType<typeof createWorld>): Promise<(string | null)[]> => {
+    const entities: readonly Entity[] = await select(world, { required: [order], order: { [order]: true } });
+    return readEach(world, entities, label);
+};
+
+const arena = async (world: ReturnType<typeof createWorld>): Promise<number> => (await world.tables()).arena;
+
+/** Once the world's joined threads are as `accept` takes them. */
+const until = (world: ReturnType<typeof createWorld>, accept: (threads: readonly { readonly status: string }[]) => boolean): Promise<void> => new Promise(resolve => {
+    let done = false;
+    const stop = world.threads(threads => {
+        if (done || !accept(threads)) return;
+        done = true;
+        queueMicrotask(() => stop());
+        resolve();
+    });
+});
+
+describe("strings", () => {
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it("are written and read back as they were given", async () => {
+        const world = createWorld({ [workers]: 0, [title]: "Hello 👋" });
+        await world.run(spawn, { count: 1000, from: 0 });
+        expect(await labels(world)).toEqual(Array.from({ length: 1000 }, (_, i) => textOf(i)));
+        await world.run(rename, { suffix: "!" });
+        expect(await labels(world)).toEqual(Array.from({ length: 1000 }, (_, i) => `${textOf(i)}!`));
+        await world.run(relabel, { suffix: "?" });
+        expect(await labels(world)).toEqual(Array.from({ length: 1000 }, (_, i) => `${textOf(i)}?`));
+        await world.run(noted);
+        const entities: readonly Entity[] = await select(world, { required: [order], order: { [order]: true } });
+        expect(await readEach(world, entities, note)).toEqual(entities.map(() => null));
+        await world.run(annotate);
+        expect(await readEach(world, entities, note)).toEqual(entities.map((_, i) => i % 3 === 0 ? null : `note ${i}`));
+        await world.run(unannotate);
+        expect(await readEach(world, entities, note)).toEqual(entities.map(() => null));
+        expect([await readResource(world, mode), await readResource(world, title)]).toEqual(["view", "Hello 👋"]);
+        await world.run(edit, { title: "Bye" });
+        expect([await readResource(world, mode), await readResource(world, title)]).toEqual(["edit", "Bye"]);
+        await world.dispose();
+    });
+    it("are kept in shared memory while a joined thread may read them, from its share until it's gone", async () => {
+        const world = createWorld({ [workers]: 0 });
+        // Every run's report is an entity, up to the reports retained, which this holds no more past.
+        await fillReports(world);
+        // Records of more than 512 bytes are the arena's own blocks, so the arena shows them freed.
+        await world.run(spawnLong, { count: 1000 });
+        const alone = await arena(world);
+        const channel = new MessageChannel();
+        world.share(channel.port1);
+        const remote = join(channel.port2, { threads: [] });
+        await until(world, threads => threads.at(-1)?.status === "joined");
+        const shared = await arena(world);
+        expect(shared - alone).toBeGreaterThan(1000 * 1024);
+        await remote.dispose();
+        await until(world, threads => threads.at(-1)?.status === "gone");
+        // Let go between runs, then freed once two sync points have passed.
+        for (let k = 0; k < 3; k++) await world.run(pass);
+        expect(await arena(world)).toBeLessThan(alone + 64 * 1024);
+        expect((await labels(world)).every(text => text?.length === 400)).toBe(true);
+        await world.dispose();
+    });
+    it("keep their values as their entities move between archetypes and others leave", async () => {
+        const world = createWorld({ [workers]: 0 });
+        await world.run(spawn, { count: 50, from: 0 });
+        await world.run(tag);
+        await world.run(despawnEven);
+        await world.run(untag);
+        expect(await labels(world)).toEqual(Array.from({ length: 25 }, (_, i) => textOf(2 * i + 1)));
+        await world.dispose();
+    });
+    it("free a replaced, removed or despawned string's record, so rewriting, removing and spawning again holds no more", async () => {
+        const world = createWorld({ [workers]: 0 });
+        // Records are kept while a joined thread may read them.
+        const channel = new MessageChannel();
+        world.share(channel.port1);
+        const remote = join(channel.port2, { threads: [] });
+        // Every run's report is an entity, up to the reports retained, which this holds no more past.
+        await fillReports(world);
+        await world.run(spawn, { count: 200, from: 0 });
+        /** What the world holds after `rounds` more, once a first round reached its steady state. */
+        const heldAfter = async (rounds: number, round: (n: number) => Promise<unknown>): Promise<readonly [number, number]> => {
+            // Replaced records are reused once a sync point has passed since, and the tables grow once.
+            for (let n = 0; n < 4; n++) await round(n);
+            const steady = await arena(world);
+            for (let n = 0; n < rounds; n++) await round(n);
+            return [await arena(world), steady];
+        };
+        const [rewritten, rewriting] = await heldAfter(20, n => world.run(n % 2 === 0 ? rename : relabel, { suffix: ` ${n % 2}` }));
+        expect(rewritten).toBeLessThanOrEqual(rewriting);
+        const [readded, readding] = await heldAfter(6, async n => {
+            await world.run(unlabel);
+            await world.run(labelAgain, { suffix: ` ${n % 2}` });
+        });
+        expect(readded).toBeLessThanOrEqual(readding);
+        const [respawned, respawning] = await heldAfter(6, async n => {
+            await world.run(despawn);
+            await world.run(spawn, { count: 200, from: 0 });
+            await world.run(rename, { suffix: ` ${n % 2}` });
+        });
+        expect(respawned).toBeLessThanOrEqual(respawning);
+        await remote.dispose();
+        await world.dispose();
+    });
+    it("are held as they are where there's no shared memory", async () => {
+        vi.stubGlobal("crossOriginIsolated", false);
+        const world = createWorld({ [workers]: 0, [title]: "Hello" });
+        await world.run(spawn, { count: 100, from: 0 });
+        await world.run(rename, { suffix: "!" });
+        expect(await labels(world)).toEqual(Array.from({ length: 100 }, (_, i) => `${textOf(i)}!`));
+        await world.run(edit, { title: "Bye" });
+        expect(await readResource(world, title)).toBe("Bye");
+        await world.dispose();
+    });
+});