@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/thread-finalizers.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Leaf } from '../../interface/finalizer/created.js';
 import { labelOf } from '../../interface/registry/index.js';
 import { objectLayout, viewsOf, type Layout } from '../../interface/registry/layout.js';
@@ -5,12 +6,12 @@ import { writeOf } from './archetype.js';
 import { emptyViews } from './arrays.js';
 import { readCell } from './cells.js';
 import { logFinalizedWord, logStopsWord, nullTag, ownTag, slotTags, startTag } from './move-log.js';
-import { stagedValue, type Mirror, type Previously } from './mirror.js';
+import { resourceValueOf, stagedValue, type Mirror, type Previously } from './mirror.js';
 import type { WorkerError } from './protocol.js';
 import { rowBinderOf, type Row, type RowArchetype, type RowHost, type RowStorage } from './rows.js';
 import {
     archetypesAt, blockGroupsWord, blockHeaderBytes, blockNextWord, blockSyncWord, columnBytes, entitiesAt, groupBytesWord, groupCountWord,
-    groupIndexWord, rowsAt, tagsAt, valuesAt,
+    groupIndexWord, resourceOffsetsOf, rowsAt, tagsAt, valuesAt,
 } from './stop-lists.js';
 import type { Key } from './state.js';
 import type { StringStore } from './strings.js';
@@ -22,7 +23,7 @@ import type { StringStore } from './strings.js';
 /** A storage of a joined thread's view, as its finalizers' rows read it. */
 type FinalizedStorage = RowStorage & { readonly component: number };
 /** An archetype of a joined thread's view, as its systems see it. */
-type FinalizedArchetype = RowArchetype & { readonly components: readonly number[]; readonly resource: boolean; readonly meta: boolean; readonly storageById: readonly (FinalizedStorage | undefined)[] };
+type FinalizedArchetype = RowArchetype & { readonly components: readonly number[]; readonly resource: boolean; readonly storageById: readonly (FinalizedStorage | undefined)[] };
 
 /** What a joined thread gives its finalizers. */
 export type ThreadFinalizersHost<A extends FinalizedArchetype> = {
@@ -38,7 +39,7 @@ export type ThreadFinalizersHost<A extends FinalizedArchetype> = {
     readonly resourceRow: () => { readonly archetype: A; readonly row: number } | null;
     /** The records strings' columns name: a stop list's copies, for its strings. */
     readonly strings: StringStore;
-    /** Posts what finalizers threw, by their index here, for the world's next report. */
+    /** Posts what finalizers threw, by their index here, which the world reports out of band. */
     readonly failed: (errors: readonly (readonly [number, WorkerError])[]) => void;
 };
 
@@ -61,15 +62,20 @@ type ThreadFinalizer = {
     readonly constants: readonly number[];
     readonly constantLayouts: readonly Layout[];
     readonly bind: (archetype: RowArchetype) => Row;
+    /** Its optional components, which a stop's row has only where the entity's archetype did. */
+    readonly optional: readonly number[];
     readonly context: object;
-    /** Resolves its resources' cells, as of now. */
-    readonly cells: () => void;
+    /**
+     * Resolves its resources: its thread's objects as it holds them, and the rest from the copies a group holds from
+     * byte `copies`, as before its stops' sync point applied, or with -1, once the world is disposed, where they are.
+     */
+    readonly cells: (copies: number) => void;
     readonly body: (row: object, context: object) => void;
 };
 
 /** A storage a stop list's column holds, for a row over its stops. */
 const columnStorage = (component: number, layout: Layout, views: RowStorage["views"], values: unknown[], strings: StringStore | null): FinalizedStorage => ({
-    component, layout, views, strings: layout.kind === "string" ? strings : null, values, ...writeOf(layout), ticked: false, added: noTicks, changed: noTicks, chunkAdded: noTicks, chunkChanged: noTicks, tags: noTags,
+    component, layout, views, strings: layout.kind === "string" ? strings : null, values, ...writeOf(layout), ticked: false, added: noTicks, changed: noTicks, chunkAdded: noTicks, chunkChanged: noTicks, blockAdded: noTicks, blockChanged: noTicks, tags: noTags,
 });
 
 /**
@@ -127,11 +133,44 @@ export const createThreadFinalizers = <A extends FinalizedArchetype>(host: Threa
         const keys = [...new Set<Key>(resources?.read ?? [])];
         const numbers = keys.map(host.numberOf);
         const resolved: { storage: FinalizedStorage | undefined; row: number }[] = keys.map(() => ({ storage: undefined, row: 0 }));
+        // Its thread's object resources are read from the mirror, which may be behind the entity table as it replays.
+        const own = keys.map(key => host.layoutOf(key)?.kind === "object");
+        const resourceStarts = numbers.map(number => mirror.starts.get(number) ?? null);
+        const ownValues: unknown[] = keys.map(() => undefined);
+        const shared = own.includes(false);
+        // The world copies the rest for each group, in this order: by slot, its strings' handles, then its linear
+        // values, each with its key's index and layout. A constant needs no copy.
+        const stringKeys: number[] = [];
+        const stringLayouts: Layout[] = [];
+        const linearKeys: number[] = [];
+        const linearLayouts: Layout[] = [];
+        const linearStrides: number[] = [];
+        const constantKeys: number[] = [];
+        const constantStorages: FinalizedStorage[] = [];
+        keys.forEach((key, k) => {
+            const layout = host.layoutOf(key);
+            if (layout === undefined || layout.kind === "object") return;
+            if (layout.kind === "string") {
+                stringKeys.push(k);
+                stringLayouts.push(layout);
+            }
+            else if (layout.kind === "linear") {
+                linearKeys.push(k);
+                linearLayouts.push(layout);
+                linearStrides.push(layout.stride);
+            }
+            else {
+                constantKeys.push(k);
+                constantStorages.push(columnStorage(numbers[k], layout, emptyViews, [], null));
+            }
+        });
+        const resourceOffsets = resourceOffsetsOf(stringKeys.length, linearStrides);
         if (keys.length > 0) {
             const values: object = Object.create({});
             keys.forEach((key, k) => {
                 Object.defineProperty(values, key, {
                     get: () => {
+                        if (own[k]) return ownValues[k];
                         const { storage, row } = resolved[k];
                         if (storage === undefined) throw new Error(`Resource "${labelOf(key)}" isn't in this world.`);
                         return readCell(storage, row);
@@ -145,15 +184,41 @@ export const createThreadFinalizers = <A extends FinalizedArchetype>(host: Threa
         const untyped: { body(row: object, context: object): void } = leaf;
         return {
             leaf, objects, starts, linear, layouts, constants, constantLayouts,
-            required: [...new Set([...reads, ...components.has ?? []])].map(host.numberOf),
+            required: [...new Set([...reads, ...components.has ?? []])].filter(key => !(components.optional ?? []).includes(key)).map(host.numberOf),
             excluded: (components.not ?? []).map(host.numberOf),
-            bind: rowBinderOf<RowArchetype>(host.rows, host.numberOf, reads, []),
+            optional: (components.optional ?? []).map(host.numberOf),
+            bind: rowBinderOf<RowArchetype>(host.rows, host.numberOf, reads, [], components.optional),
             context: value,
-            cells: () => {
-                const found = keys.length === 0 ? null : host.resourceRow();
-                for (let k = 0; k < keys.length; k++) {
-                    resolved[k].storage = found?.archetype.storageById[numbers[k]];
-                    resolved[k].row = found?.row ?? 0;
+            cells: copies => {
+                // Before a rebuild too, its old rows are the mirror's, which hold what the rebuild keeps.
+                for (let k = 0; k < keys.length; k++) if (own[k]) ownValues[k] = resourceValueOf(mirror, numbers[k], resourceStarts[k]);
+                if (!shared) return;
+                if (copies < 0) {
+                    const found = host.resourceRow();
+                    for (let k = 0; k < keys.length; k++) {
+                        if (own[k]) continue;
+                        resolved[k].storage = found?.archetype.storageById[numbers[k]];
+                        resolved[k].row = found?.row ?? 0;
+                    }
+                    return;
+                }
+                if (stringKeys.length > 0) {
+                    // One view over every handle, a slot each.
+                    const views = viewsOf(buffer, copies, 4 * stringKeys.length);
+                    for (let slot = 0; slot < stringKeys.length; slot++) {
+                        const k = stringKeys[slot];
+                        resolved[k].storage = columnStorage(numbers[k], stringLayouts[slot], views, [], host.strings);
+                        resolved[k].row = slot;
+                    }
+                }
+                for (let slot = 0; slot < linearKeys.length; slot++) {
+                    const k = linearKeys[slot];
+                    resolved[k].storage = columnStorage(numbers[k], linearLayouts[slot], viewsOf(buffer, copies + resourceOffsets[slot], linearStrides[slot]), [], null);
+                    resolved[k].row = 0;
+                }
+                for (let slot = 0; slot < constantKeys.length; slot++) {
+                    resolved[constantKeys[slot]].storage = constantStorages[slot];
+                    resolved[constantKeys[slot]].row = 0;
                 }
             },
             body: (row, context) => untyped.body(row, context),
@@ -233,12 +298,53 @@ export const createThreadFinalizers = <A extends FinalizedArchetype>(host: Threa
                 storageById[linear[k]] = columnStorage(linear[k], layout, viewsOf(buffer, column, count * stride), [], host.strings);
                 column += columnBytes(count, stride);
             }
-            for (let k = 0; k < finalizer.constants.length; k++) storageById[finalizer.constants[k]] = columnStorage(finalizer.constants[k], finalizer.constantLayouts[k], emptyViews, [], null);
-            const row = finalizer.bind({ id: -1, entities: new Float64Array(buffer, entitiesAt(group), count), storageById });
-            finalizer.cells();
-            for (let i = 0; i < count; i++) {
-                row.index = i;
-                guarded(index, finalizer, row);
+            // A shared component's value is each stop's archetype's, bound a run of one archetype's stops at a time.
+            const shared: number[] = [];
+            for (let k = 0; k < finalizer.constants.length; k++) {
+                const component = finalizer.constants[k];
+                const layout = finalizer.constantLayouts[k];
+                if (layout.kind === "constant" && layout.shared === true) shared.push(component);
+                else storageById[component] = columnStorage(component, layout, emptyViews, [], null);
+            }
+            const entities = new Float64Array(buffer, entitiesAt(group), count);
+            finalizer.cells(column);
+            if (finalizer.optional.length === 0 && shared.length === 0) {
+                const row = finalizer.bind({ id: -1, entities, storageById });
+                for (let i = 0; i < count; i++) {
+                    row.index = i;
+                    guarded(index, finalizer, row);
+                }
+            }
+            else {
+                // A stop's row has an optional component only where its archetype did: rows run a run of one
+                // archetype's stops at a time, and archetypes with the same ones share their copy of the columns.
+                const byPattern = new Map<number, RowArchetype>();
+                for (let i = 0; i < count;) {
+                    const id = u32[archetypeWords + i];
+                    let end = i + 1;
+                    while (end < count && u32[archetypeWords + end] === id) end++;
+                    const components = host.archetypeAt(id)?.components ?? [];
+                    let pattern = 0;
+                    finalizer.optional.forEach((component, k) => { if (components.includes(component)) pattern |= 1 << k; });
+                    // With shared components, each archetype has its own copy, holding its values.
+                    const key = shared.length === 0 ? pattern : -1 - id;
+                    let archetype = byPattern.get(key);
+                    if (archetype === undefined) {
+                        const storages: (FinalizedStorage | undefined)[] = [...storageById];
+                        finalizer.optional.forEach((component, k) => { if ((pattern & (1 << k)) === 0) storages[component] = undefined; });
+                        const viewed = shared.length === 0 ? undefined : host.archetypeAt(id);
+                        for (const component of shared) {
+                            const layout = viewed?.storageById[component]?.layout;
+                            storages[component] = layout === undefined ? undefined : columnStorage(component, layout, emptyViews, [], null);
+                        }
+                        byPattern.set(key, archetype = { id: -1, entities, storageById: storages });
+                    }
+                    const row = finalizer.bind(archetype);
+                    for (; i < end; i++) {
+                        row.index = i;
+                        guarded(index, finalizer, row);
+                    }
+                }
             }
             group += bytes;
         }
@@ -296,10 +402,10 @@ export const createThreadFinalizers = <A extends FinalizedArchetype>(host: Threa
         for (let index = 0; index < finalizers.length; index++) {
             const finalizer = finalizers[index];
             if (finalizer === null || finalizer === undefined) continue;
-            finalizer.cells();
+            finalizer.cells(-1);
             for (let id = 0; id < host.tableCount(); id++) {
                 const archetype = host.archetypeAt(id);
-                if (archetype === undefined || archetype.resource || (archetype.meta && finalizer.required.length === 0)) continue;
+                if (archetype === undefined || archetype.resource) continue;
                 const { components } = archetype;
                 if (!finalizer.required.every(component => components.includes(component)) || finalizer.excluded.some(component => components.includes(component))) continue;
                 const count = host.countOf(archetype);

package/src/implementation/world/thread-indexes.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Layout } from '../../interface/registry/layout.js';
 import { recordKey, type HashView } from './index-hash.js';
 import { keyPartsOf } from './index-keys.js';
@@ -38,19 +39,20 @@ const u32From = (buffer: ArrayBufferLike, at: number): Uint32Array => new Uint32
 const i32From = (buffer: ArrayBufferLike, at: number): Int32Array => new Int32Array(buffer, at);
 const f64From = (buffer: ArrayBufferLike, at: number): Float64Array => new Float64Array(buffer, at);
 
-export const createThreadIndex = (rows: RowHost, archetypeAt: (id: number) => LookupArchetype | undefined, setup: ThreadIndexSetup): ThreadIndex => {
+export const createThreadIndex = (rows: RowHost, archetypeAt: (id: number) => LookupArchetype | undefined, replaced: { readonly count: number }, setup: ThreadIndexSetup): ThreadIndex => {
     const { parts, words } = keyPartsOf(setup.layouts);
     const watchedPositions = Array.from({ length: setup.watched }, (_, k) => k);
     const hashWatched = new Map<number, Float64Array>();
     const sortedWatched = new Map<number, { tree: Float64Array }>();
-    const hash: HashView | null = setup.sorted ? null : { words, stride: recordKey + words, slots: none32, records: none32, ticks: none64, cleared: 0, entries: noneI32, watched: hashWatched };
+    // The world sorts a hash index's buckets before writing its record, so this view has none unsorted.
+    const hash: HashView | null = setup.sorted ? null : { words, stride: recordKey + words, slots: none32, records: none32, ticks: none64, cleared: 0, entries: noneI32, unsorted: 0, watched: hashWatched };
     const sorted: SortedView | null = !setup.sorted ? null : {
         words, stride: sortedStride(words), parts, objects: false, entries: none32, lengths: noneI32, order: noneI32, blocks: 0, counts: noneI32, tree: none64, leaves: 1,
         fences: none32, size: 0, cleared: 0, watched: sortedWatched,
     };
     const index: IndexView = { parts, words, unique: setup.unique, hash, sorted };
     const since: Since = { value: 0 };
-    const lookup = lookupFunction({ rows, archetypeAt, index, unique: setup.unique, reads: setup.reads, readIds: setup.readIds, watched: watchedPositions, since, replaced: null });
+    const lookup = lookupFunction({ rows, archetypeAt, index, unique: setup.unique, reads: setup.reads, readIds: setup.readIds, watched: watchedPositions, since, replaced });
     const count = recordWordsOf(setup.sorted, setup.watched);
     let record: Float64Array = none64;
     const refresh = (buffer: ArrayBufferLike): void => {

package/src/implementation/world/thread-observer.ts

@@ -1,7 +1,8 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Commands } from '../../interface/system/commands.js';
 import type { Leaf } from '../../interface/system/leaf.js';
-import { definitionOf, isLeaf, itemOfId, labelOfItem } from '../../interface/registry/index.js';
-import { cancelled, notRun, opening, outcomeWord, postedWord, removedWord, runsWord, observerBlockWords, syncWord, tickSlot } from './joined-observer.js';
+import { definitionOf, idOrNull, isLeaf, itemOfId } from '../../interface/registry/index.js';
+import { cancelled, notRun, opening, outcomeWord, postedWord, removedWord, runsWord, observerBlockWords, syncWord, tickSlot, worldRunValued } from './joined-observer.js';
 import { protocolName, type ObserverSetup, type ToWorld } from './joining.js';
 import type { Mirror } from './mirror.js';
 import type { WorkerError } from './protocol.js';
@@ -25,14 +26,16 @@ export type ThreadObserverHost = {
 };
 
 /**
- * An observer system of this thread's own, by its number for it: its value, its runner once the world placed it, and
- * the newest of its runs a post ran for.
+ * An observer system of this thread's own, by its number for it: its value, its runner once the world placed it, the
+ * newest of its runs a post ran for, and what that post's body returned or threw, which those runs settle with.
  */
 export type Local = {
     readonly number: number;
     readonly leaf: Leaf;
     runner: ThreadRunner | null;
     ran: number;
+    value: unknown;
+    error: unknown;
     /** Whether it's placed on this thread now: false once removed, until placed again. */
     placed: boolean;
     /** The last of this thread's runs posted before it was last removed here: those that didn't run then never do. */
@@ -49,6 +52,8 @@ type Block = { readonly control: Int32Array; readonly ticks: Float64Array; handl
 type Placed = {
     readonly index: number;
     readonly label: string;
+    /** The id the plugin gave it, which failures give beside its label. */
+    readonly id: string | null;
     readonly blocks: readonly Block[];
     /** Whether its posts read only their blocks, never this thread's objects. */
     readonly contained: boolean;
@@ -70,11 +75,33 @@ const noStamps: number[] = [];
 export const createThreadObserver = (host: ThreadObserverHost) => {
     const { directory, mirror } = host;
     const runnerHost: RunnerHost = {
-        rows: directory.rows, archetypeAt: directory.archetypeAt, countOf: directory.countOf, tableCount: directory.tableCount,
+        rows: directory.rows, archetypeAt: directory.archetypeAt, countOf: directory.countOf, arrivals: directory.arrivals, tableCount: directory.tableCount,
         resourceRow: directory.resourceRow, refreshEntities: directory.refreshEntities, commands: noCommands,
-        numberOf: directory.numberOf, layoutOf: directory.layoutOf, mirror, refresh: directory.refresh, strings: directory.strings,
+        numberOf: directory.numberOf, layoutOf: directory.layoutOf, mirror, refresh: directory.refresh, replaced: directory.replaced, strings: directory.strings,
     };
     const placed: (Placed | undefined)[] = [];
+    /** What posts owed to runs of the world's gave back, in this `process`. */
+    let results: [number, unknown, WorkerError | null][] | null = null;
+
+    /** Posts what runs of the world's resolve to; a value that can't be posted, as a function, fails its run instead. */
+    const postResults = (given: [number, unknown, WorkerError | null][]): void => {
+        try {
+            host.post({ protocol: protocolName, kind: "observer ran", results: given });
+            return;
+        }
+        catch {
+            // Posted one by one, to tell which can't be.
+        }
+        for (const result of given) {
+            try {
+                host.post({ protocol: protocolName, kind: "observer ran", results: [result] });
+            }
+            catch (error) {
+                const message = `Its value can't be posted to the world's thread: ${error instanceof Error ? error.message : String(error)}`;
+                host.post({ protocol: protocolName, kind: "observer ran", results: [[result[0], undefined, { name: "Error", message }]] });
+            }
+        }
+    };
 
     /** Records observer systems the world places here; one by an id this thread never imported doesn't run. */
     const setup = (systems: readonly ObserverSetup[]): void => {
@@ -91,13 +118,13 @@ export const createThreadObserver = (host: ThreadObserverHost) => {
                 if (own === undefined) continue;
                 own.runner = createThreadRunner(runnerHost, own.leaf, records);
                 own.placed = true;
-                placed[index] = { index, label: labelOfItem(own.leaf), blocks, contained, runner: null, local: new WeakRef(own), stopped: false };
+                placed[index] = { index, label: own.leaf.name, id: idOrNull(own.leaf), blocks, contained, runner: null, local: new WeakRef(own), stopped: false };
                 continue;
             }
             const item = id === null ? undefined : itemOfId(id);
             const definition = item === undefined ? undefined : definitionOf(item);
             const leaf = definition !== undefined && isLeaf(definition) ? definition : null;
-            placed[index] = { index, label: leaf === null ? String(id) : labelOfItem(leaf), blocks, contained, runner: leaf === null ? null : createThreadRunner(runnerHost, leaf, records), local: null, stopped: false };
+            placed[index] = { index, label: leaf === null ? String(id) : leaf.name, id: leaf === null ? null : idOrNull(leaf), blocks, contained, runner: leaf === null ? null : createThreadRunner(runnerHost, leaf, records), local: null, stopped: false };
         }
     };
 
@@ -135,7 +162,7 @@ export const createThreadObserver = (host: ThreadObserverHost) => {
     /** Gives back a claim it can't run yet, owed to a run: run nothing, and the world posts it again between runs. */
     const giveBack = (control: Int32Array): void => {
         finishUnrun(control);
-        if (Atomics.load(control, runsWord) > 0) host.post({ protocol: protocolName, kind: "observer again" });
+        if (Atomics.load(control, runsWord) !== 0) host.post({ protocol: protocolName, kind: "observer again" });
     };
 
     /**
@@ -160,8 +187,11 @@ export const createThreadObserver = (host: ThreadObserverHost) => {
             }
             // Claimed, the post in the block stays until it's done, so its posted word is this one's.
             block.handled = Atomics.load(control, postedWord);
+            // A run of the world's waits for what this post gave: one this thread can't run fails it, saying why.
+            const owed = Atomics.load(control, runsWord) < 0 && runner === null && !entry.stopped && Atomics.load(control, removedWord) === 0;
             finishUnrun(control);
-            return false;
+            if (owed) (results ??= []).push([entry.index, undefined, { name: "Error", message: `System "${entry.label}" was placed on this joined thread, which never imported it, so it can't run here.` }]);
+            return owed;
         }
         // This thread's objects are read as of the post's sync: replayed through the newest first.
         const bounded = mirror !== null && !entry.contained;
@@ -188,7 +218,20 @@ export const createThreadObserver = (host: ThreadObserverHost) => {
         // Read first: the world may write its next post here once this one says what it did.
         const runs = Atomics.load(control, runsWord);
         const outcome = runner.runTail(block.ticks[1], undefined, control, sync, 0, noStamps, claimed, outcomeWord);
-        if (own !== undefined && runs > 0) own.ran = Math.max(own.ran, runs);
+        // A post owed to this thread's own runs settles them with what it returned or threw.
+        if (own !== undefined && runs > 0) {
+            own.ran = Math.max(own.ran, runs);
+            own.value = outcome.value;
+            own.error = outcome.error;
+            outcome.value = undefined;
+            return true;
+        }
+        // A post owed to a run of the world's gives it what its body returned or threw.
+        if (own === undefined && runs < 0) {
+            (results ??= []).push([entry.index, outcome.error === undefined && runs === worldRunValued ? outcome.value : undefined, outcome.error === undefined ? null : errorOf(outcome.error)]);
+            outcome.value = undefined;
+            return true;
+        }
         if (outcome.error !== undefined) {
             const found = errors ?? [];
             found.push([entry.index, errorOf(outcome.error)]);
@@ -198,12 +241,14 @@ export const createThreadObserver = (host: ThreadObserverHost) => {
     };
 
     /**
-     * Runs every new post here; returns how many ran. What one threw goes to the world, for its next report.
-     * Of a system's two blocks, only one holds a post it hasn't claimed, the newest.
+     * Runs every new post here; returns how many ran. What one threw goes to the world, which reports it out of band,
+     * unless the post was owed to this thread's own runs, which reject with it. Of a system's two blocks, only one
+     * holds a post it hasn't claimed, the newest.
      */
     const process = (): number => {
         let ran = 0;
         let errors: [number, WorkerError][] | null = null;
+        results = null;
         for (let k = 0; k < placed.length; k++) {
             const entry = placed[k];
             if (entry === undefined) continue;
@@ -215,6 +260,8 @@ export const createThreadObserver = (host: ThreadObserverHost) => {
             }
         }
         if (errors !== null && errors.length > 0) host.post({ protocol: protocolName, kind: "observer failed", errors });
+        if (results !== null) postResults(results);
+        results = null;
         return ran;
     };
 

package/src/implementation/world/thread-systems-worker.fixture.ts

@@ -1,9 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { MessagePort as NodeMessagePort } from "node:worker_threads";
 import type { World } from "../../interface/world/world.js";
 import { asEntity } from "./entities.js";
 import { join } from "./create.js";
 import { scopeChannel } from "./port.js";
-import { idle } from "./joining.test-helper.js";
 import { objectsThere, ranHere } from "./thread-systems.test-helper.js";
 
 /**
@@ -32,7 +32,7 @@ let remote: World | null = null;
 channel.onMessage(async message => {
     if ("protocol" in message) return;
     if (message.kind === "join") {
-        remote = join(message.port, { threads: ["threadSystemsTest"] });
+        remote = await join(message.port, { threads: ["threadSystemsTest"] });
         channel.post({ kind: "joined" });
     }
     else if (message.kind === "objects") {
@@ -62,9 +62,8 @@ channel.onMessage(async message => {
         setTimeout(() => { for (;;) { /* never yields */ } }, 0);
     }
     else {
-        const refused = join(message.port, { threads: ["threadSystemsTest"] });
-        const ran = await refused.run(idle).then(() => "ran", (error: unknown) => error instanceof Error ? error.message : String(error));
-        await refused.dispose();
-        channel.post({ kind: "refused", message: ran });
+        // Its join says why it's refused.
+        const joined = await join(message.port, { threads: ["threadSystemsTest"] }).then(() => "joined", (error: unknown) => error instanceof Error ? error.message : String(error));
+        channel.post({ kind: "refused", message: joined });
     }
 });

package/src/implementation/world/thread-systems.cases.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import type * as Fixture from "./thread-systems.fixture.js";
 
@@ -10,16 +11,28 @@ export const threadSystemsCases = (load: () => Promise<typeof Fixture>) => descr
         expect(actual.reports).toEqual(expected.reports);
         expect(actual.warnings[1].length).toBe(7);
     }, 30000);
+    it("resolve the world's runs of them to what their bodies returned there, observer systems' included, posting no other values", async () => {
+        const fixture = await load();
+        expect(await fixture.valuesThere()).toEqual({
+            system: "plain",
+            observer: "plain",
+            observerFails: expect.stringMatching(/^System "paintObservedFails" .*failed: threadSystemsTest observer failure there$/),
+            unpostable: expect.stringMatching(/^System "paintReader" .*failed: Its value can't be posted to the world's thread/),
+            composite: undefined,
+            reported: 0,
+        });
+    }, 30000);
     it("are skipped with a \"thread\" failure when the worker dies mid-task, and run on the world's thread once it's gone", async () => {
         const fixture = await load();
         expect(await fixture.diesMidTask()).toEqual({
-            report: { failures: [["thread", "threadSystemsTest/stall", 'Thread "threadSystemsTest" is gone, so its systems don\'t run.']], skipped: ["threadSystemsTest/stall"] },
+            report: { failures: [["thread", "stall", 'Thread "threadSystemsTest" is gone, so its systems don\'t run.']], skipped: ["stall"] },
             after: 0,
         });
     }, 30000);
     it("can't join claiming the thread of a system the joined thread never imported", async () => {
         const fixture = await load();
-        expect(await fixture.unimported()).toBe('System "threadSystemsTest/onlyHere" runs on thread "threadSystemsTest", which the joined thread claiming it never imported.');
+        const refused = 'System "onlyHere" runs on thread "threadSystemsTest", which the joined thread claiming it never imported.';
+        expect(await fixture.unimported()).toEqual({ joined: refused, shared: refused });
     }, 30000);
     it("don't stall ticks that don't touch their thread when it never yields", async () => {
         const fixture = await load();

package/src/implementation/world/thread-systems.fixture.ts

@@ -1,13 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
 import { Observe } from "../../observe/index.js";
 import { always } from "../../interface/resources/always.js";
 import { workers } from "../../interface/resources/workers.js";
 import { System } from "../../interface/system/system.js";
-import { createWorld, type CreatedWorld } from "./create.js";
+import { createWorld, recorderOf, type CreatedWorld } from "./create.js";
 import { backToBack } from "./loop.js";
 import type { FromThreadSystemsWorker, ToThreadSystemsWorker } from "./thread-systems-worker.fixture.js";
-import { caption, changes, count, countThere, counted, scenario, stall } from "./thread-systems.test-helper.js";
-import { reportOf, runReported } from "./reports.test-helper.js";
+import { caption, changes, count, countThere, counted, paintObserved, paintObservedFails, paintReader, paintThere, paintsTogether, scenario, stall } from "./thread-systems.test-helper.js";
+import { catchOutOfBand, reportOf, runReported } from "./outcomes.test-helper.js";
 
 /**
  * Scenarios of systems on a joined worker, run built in node and from source in chromium: the same runs as an inline
@@ -15,7 +16,7 @@ import { reportOf, runReported } from "./reports.test-helper.js";
  */
 
 /** A system on the worker's thread, which only this module declares, so the worker never imported it. */
-const onlyHere = System.create({ name: "threadSystemsTest/onlyHere", components: { read: [caption] } }, row => { void row[caption]; });
+const onlyHere = System.create({ components: { with: [caption] } }, row => { void row[caption]; });
 
 type Worker = {
     readonly ask: (message: ToThreadSystemsWorker, transfer?: readonly unknown[]) => Promise<FromThreadSystemsWorker>;
@@ -80,10 +81,10 @@ const within = <T>(promise: Promise<T>, milliseconds: number, otherwise: T): Pro
 /** A world shared with a worker that joins it claiming "threadSystemsTest", once it joined. */
 const joined = async (world: CreatedWorld): Promise<{ readonly worker: Worker }> => {
     const { port1, port2 } = new MessageChannel();
-    world.share(port1);
+    const shared = world.share(port1);
     const worker = start();
     await worker.ask({ kind: "join", port: port2 }, [port2]);
-    await until(world.threads, threads => threads.at(-1)?.status === "joined");
+    await shared;
     return { worker };
 };
 
@@ -107,11 +108,12 @@ export const sameResults = async () => {
 export const diesMidTask = async () => {
     const world = createWorld({ [workers]: 0 });
     const { worker } = await joined(world);
-    const running = world.run(stall);
+    recorderOf(world);
+    // Followed at once, so its rejection is handled as it comes.
+    const reporting = reportOf(world, world.run(stall));
     await new Promise(resolve => setTimeout(resolve, 50));
     await worker.terminate();
-    const ran = await within(running, 20000, null);
-    const report = ran === null ? null : await reportOf(world, ran);
+    const report: Awaited<typeof reporting> | null = await within(reporting, 20000, null);
     // Placed here again once its claims are released: a run on the world's thread.
     const after = report === null ? null : await within(runReported(world, count), 20000, null);
     await world.dispose();
@@ -121,17 +123,40 @@ export const diesMidTask = async () => {
     };
 };
 
-/** A worker claiming the thread of a system it never imported: why its run rejects. */
+/**
+ * Runs from the world's thread of systems on the joined worker: what a system's and an observer system's run there
+ * resolves to, what one throwing there and one returning what can't be posted reject with, and that composites and ticks
+ * of members returning values don't fail.
+ */
+export const valuesThere = async () => {
+    using reported = catchOutOfBand();
+    const world = createWorld({ [workers]: 0 });
+    const { worker } = await joined(world);
+    const rejected = (run: Promise<unknown>): Promise<string> => run.then(() => "resolved", (error: unknown) => error instanceof Error ? error.message : String(error));
+    const result = {
+        system: await world.run(paintThere),
+        observer: await world.run(paintObserved),
+        observerFails: await rejected(world.run(paintObservedFails)),
+        unpostable: await rejected(world.run(paintReader)),
+        composite: await world.run(paintsTogether),
+        reported: 0,
+    };
+    await world.dispose();
+    await worker.terminate();
+    return { ...result, reported: reported.errors.length };
+};
+
+/** A worker claiming the thread of a system it never imported: why its join rejects, and why the world's share does. */
 export const unimported = async () => {
     const world = createWorld({ [workers]: 0 });
     await world.run(onlyHere);
     const { port1, port2 } = new MessageChannel();
-    world.share(port1);
+    const shared = world.share(port1).then(() => "joined", (error: unknown) => error instanceof Error ? error.message : String(error));
     const worker = start();
     const reply = await worker.ask({ kind: "refused", port: port2 }, [port2]);
     await worker.terminate();
     await world.dispose();
-    return reply.kind === "refused" ? reply.message : null;
+    return { joined: reply.kind === "refused" ? reply.message : null, shared: await shared };
 };
 
 /** Ticks of a world-only system, back to back, while the joined worker claiming a thread never yields: how many ran. */
@@ -174,6 +199,8 @@ const reachedOrStopped = (observe: Observe<number>, target: number, milliseconds
  * once they stopped for 5 s, as when a wake notified no one.
  */
 export const ticksThere = async (ticks: number) => {
+    // Ticks once the worker is ended skip its systems, a "thread" failure reported out of band.
+    using _reported = catchOutOfBand();
     const driver = backToBack();
     const world = createWorld({ [workers]: 0, [always]: true }, { loop: driver });
     const { worker } = await joined(world);
@@ -191,6 +218,8 @@ export const ticksThere = async (ticks: number) => {
  * when they didn't all run within 20 s, as when it never returns.
  */
 export const timerWhileTicking = async () => {
+    // Ticks once the worker is ended skip its systems, a "thread" failure reported out of band.
+    using _reported = catchOutOfBand();
     const driver = backToBack();
     const world = createWorld({ [workers]: 0, [always]: true }, { loop: driver });
     const { worker } = await joined(world);