@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/state.ts

@@ -1,7 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { createHolds, type Holds } from './stop-lists.js';
 import type { Entity } from '../../interface/entity/entity.js';
-import { declarationOf, firstKeyOf, kindOf, labelOf } from '../../interface/registry/index.js';
-import { createArchetype, startTicks, type Archetype, type Storage } from './archetype.js';
+import type { Leaf } from '../../interface/system/leaf.js';
+import { declarationOf, firstKeyOf, kindOf, labelOf, whyUnregistered } from '../../interface/registry/index.js';
+import type { Arrivals } from './arrivals.js';
+import { createArchetype, noShared, startTicks, type Archetype, type Storage } from './archetype.js';
+import { createSharedValues, holdShared, internShared, type SharedValues } from './shared.js';
+import { noteEdge, reuseArchetype } from './reclaim.js';
 import type { SpawnBatch } from './staging.js';
 import type { CommandBuffer } from './buffer.js';
 import type { ListShape, Recent } from './lists.js';
@@ -14,6 +19,7 @@ import type { FinalizerRunner, Thrown } from './finalizers.js';
 import { createPlan, type Plan } from './plan.js';
 import { createStructure, owner, restratify, weak, type Structure } from './structure.js';
 import { layoutOf, objectLayout, type Layout } from '../../interface/registry/layout.js';
+import { numberConstants } from '../../interface/registry/schemas.js';
 import { createMemory, type Memory } from './memory.js';
 import { createStrings, type StringStore } from './strings.js';
 import { createLayoutDirectory, type LayoutDirectory } from './layout-directory.js';
@@ -26,7 +32,7 @@ import { createObserverState, type ObserverState } from './joined-observer.js';
 import { claimComponent } from './remote.js';
 import type { IndexDefinition } from '../../interface/registry/index.js';
 import type { WorldIndex } from './indexes.js';
-import type { Failure } from '../../interface/report/failure.js';
+import type { Failure } from './failures.js';
 
 export type Key = string | symbol;
 
@@ -92,8 +98,34 @@ export type State = {
     readonly archetypeByKey: Map<string, Archetype>;
     readonly ids: Map<Key, number>;
     readonly keys: Key[];
-    /** By component: how its values are stored here, strings as objects where there's no shared memory. */
+    /**
+     * By component: how its values are stored here, strings as objects where there's no shared memory. A shared
+     * component's is a constant of its start; each archetype's storage of it holds its own value.
+     */
     readonly layouts: Layout[];
+    /** By component id: a shared component's values, interned; undefined for every other, which pays nothing for them. */
+    readonly shared: (SharedValues | undefined)[];
+    /** Each shared component's values, as `shared` holds them, in a list of their own. */
+    readonly sharedList: SharedValues[];
+    /** Whether the world has met a shared component, so archetypes are found by values too. */
+    sharing: boolean;
+    /** Whether a system with `where` and change filters registered, so sync points log rows' moves (`arrivals.ts`). */
+    arrivals: boolean;
+    /** The ring of rows' moves between archetypes, from the first logged; null before. */
+    arrivalRing: Arrivals | null;
+    /** By component set, archetypes of shared values reclaimed, waiting to be reused for others (`reclaim.ts`). */
+    readonly pools: Map<string, Archetype[]>;
+    /** Archetypes of shared values found empty, which may be reclaimed. */
+    readonly emptied: Archetype[];
+    /**
+     * Archetypes reclaimed or reused, in order, which systems' match lists follow from their own position: the log
+     * holds those from `base` on, trimmed as it grows.
+     */
+    readonly membership: { readonly log: Archetype[]; base: number };
+    /** How many archetypes were reclaimed or reused, the membership log's end: one number a system's run compares. */
+    reshapes: number;
+    /** Sync points applied, which reclaiming counts. */
+    syncs: number;
     /** The records strings' columns name, in shared memory; null without it, where strings are held as objects. */
     readonly strings: StringStore | null;
     /** Whether each component is derived, so only rules add and remove it. */
@@ -137,8 +169,9 @@ export type State = {
     readonly batches: SpawnBatch[];
     readonly batchByKey: Map<string, SpawnBatch>;
     /**
-     * Lists of components commands named, by their sorted ids; archetypes by their program-wide index, and the last
-     * eight plain lists, which find them first.
+     * Lists of components commands named, by their sorted ids; lists the build gave indexes, and those made at runtime
+     * that keep one while their keys stay the same, by their index; and the last eight made at runtime, by their keys,
+     * which find copies of them before they keep their own (`lists.ts`).
      */
     readonly lists: Map<string, readonly ListShape[]>;
     readonly byIndex: ListShape[];
@@ -164,6 +197,12 @@ export type State = {
     /** Whether kernels with a program run as WASM, and as SIMD where they can; tests turn these off to compare with JS. */
     readonly wasm: boolean;
     readonly simd: boolean;
+    /**
+     * Rows of an archetype a kernel runs here at which it wants the pool, while none is started: infinite with a pool,
+     * or without workers to start. A kernel reaching it sets `poolWanted`, and the next run starts the pool.
+     */
+    poolThreshold: number;
+    poolWanted: boolean;
     /** The sync point's plan, kept from planning to applying. */
     readonly plan: Plan;
     /** A sync point between planning and applying: its queued buffers, reservations and tick. */
@@ -208,10 +247,12 @@ export type State = {
     readonly claims: Map<string, MoveLog>;
     readonly logs: MoveLog[];
     claimed: boolean;
-    /** What the run in progress ran, for its report: systems, whether any ran on `main`, GPU work, joined threads' logs. */
+    /** The system without components whose body's value the run in progress resolves to; null for none, as in a tick. */
+    wanted: Leaf | null;
+    /** While a finalizer's failure is reported out of band, the finalizers each sync point ran, which then recover. */
+    finalized: Set<object> | null;
+    /** What the run in progress ran: systems, whether any ran on `main`, GPU work, joined threads' logs. */
     readonly ran: Ran;
-    /** Report components, whose archetypes only queries that require a component see. */
-    readonly meta: Set<number>;
     /** Whether a joined thread reads the layout directory's counts: one holds claims, or has observer systems placed. */
     counting: boolean;
     /** Observer systems on joined threads (`joined-observer.ts`). */
@@ -226,7 +267,7 @@ export type State = {
     /** Moves on whenever a registered system's runner is replaced, so runs read runners again only then. */
     runnersVersion: number;
     /**
-     * Failures of finalizers the next sync point reports: those on claimed threads that can't run there, which don't
+     * Failures of finalizers the next sync point gives its run: those on claimed threads that can't run there, which don't
      * activate, with every one found; and stops a thread that's gone never finalized.
      */
     readonly unplaced: Thrown[];
@@ -244,7 +285,7 @@ export type State = {
     readonly written: number[];
     /** The tick of the last sync point that wrote a command's value into a row. */
     valuesWritten: number;
-    /** Unique indexes' conflicts refreshes found, for the report of the run in progress. */
+    /** Unique indexes' conflicts refreshes found, failures of the run in progress. */
     readonly indexFailures: Failure[];
     /** Indexes built in phases so far, and of them across the pool, for tests of how builds run. */
     phasedBuilds: number;
@@ -266,6 +307,16 @@ export const createState = (shared?: boolean, wasm = true, simd = true, gpu = fa
         ids: new Map(),
         keys: [],
         layouts: [],
+        shared: [],
+        sharedList: [],
+        sharing: false,
+        arrivals: false,
+        arrivalRing: null,
+        pools: new Map(),
+        emptied: [],
+        membership: { log: [], base: 0 },
+        reshapes: 0,
+        syncs: 0,
         strings: memory.shared ? createStrings(memory) : null,
         derived: [],
         transfers: [],
@@ -297,6 +348,8 @@ export const createState = (shared?: boolean, wasm = true, simd = true, gpu = fa
         rows: new Map(),
         wasm,
         simd,
+        poolThreshold: Infinity,
+        poolWanted: false,
         plan: createPlan(),
         syncing: null,
         carried: null,
@@ -312,8 +365,9 @@ export const createState = (shared?: boolean, wasm = true, simd = true, gpu = fa
         claims: new Map(),
         logs: [],
         claimed: false,
+        wanted: null,
+        finalized: null,
         ran: { systems: 0, main: false, gpu: false, joined: new Set() },
-        meta: new Set(),
         counting: false,
         observer: createObserverState(),
         counted: [],
@@ -366,7 +420,7 @@ export const idOf = (state: State, key: Key): number => {
         return id;
     }
     const declaration = declarationOf(key);
-    if (declaration === undefined) throw new Error(`"${labelOf(key)}" has no registered schema; import the module that registers it.`);
+    if (declaration === undefined) throw new Error(`"${labelOf(key)}" has no registered schema: ${whyUnregistered(key)}.`);
     const { structure } = state;
     // A host gets its id first, so stratifying with the new edge can name it; a cycle throws before anything is
     // recorded.
@@ -390,10 +444,17 @@ export const idOf = (state: State, key: Key): number => {
     }
     state.ids.set(key, id);
     state.keys.push(key);
-    const declared = layoutOf(declaration.type);
+    const shared = declaration.shared === true;
+    const declared: Layout = shared ? { kind: "constant", value: defaultOf(key), shared: true } : layoutOf(declaration.type);
     // Only other threads need strings in shared memory, and there are none without it.
     const layout: Layout = declared.kind === "string" && state.strings === null ? objectLayout : declared;
     state.layouts.push(layout);
+    const values = shared ? createSharedValues(declaration.type) : undefined;
+    state.shared.push(values);
+    if (values !== undefined) {
+        state.sharing = true;
+        state.sharedList.push(values);
+    }
     state.starts.push(layout.kind === "constant" ? layout.value : defaultOf(key));
     state.commandable.push(false);
     state.written.push(0);
@@ -412,15 +473,19 @@ export const idOf = (state: State, key: Key): number => {
 };
 
 /**
- * What a resource or derived component starts at: its declaration's default or its schema's, or `null` when its type
- * allows leaving it out.
+ * What a resource or derived component starts at: a new empty `Map` or `Set` when it starts fresh, so each world has
+ * its own; its declaration's default, which the build gives; or `null` when its type allows leaving it out.
  */
 export const defaultOf = (key: Key): unknown => {
     const declaration = declarationOf(key);
     if (declaration === undefined) return null;
+    if (declaration.fresh === "Map") return new Map();
+    if (declaration.fresh === "Set") return new Set();
     if ("default" in declaration) return declaration.default;
     const { type } = declaration;
-    return type !== undefined && "default" in type ? type.default : null;
+    if (type === undefined) return null;
+    // A union of number constants starts at its first, so its value is always one of them.
+    return numberConstants(type)?.[0] ?? null;
 };
 
 /**
@@ -439,17 +504,107 @@ export const commandIdOf = (state: State, key: unknown): number => {
     return id;
 };
 
-/** The archetype for sorted component ids, created if needed. Creation allocates, so it happens only at sync points. */
-export const archetypeOf = (state: State, components: readonly number[]): Archetype => {
-    const key = components.join(",");
+/**
+ * An archetype's key: its sorted component ids, each shared one with the number of its value, so archetypes of one
+ * component set but other values are others.
+ */
+const keyOf = (state: State, components: readonly number[], values: readonly (number | undefined)[]): string => {
+    if (!state.sharing) return components.join(",");
+    let key = "";
+    for (let k = 0; k < components.length; k++) {
+        const id = components[k];
+        if (k > 0) key += ",";
+        key += state.shared[id] === undefined ? `${id}` : `${id}=${values[id] ?? missingValue(state, id)}`;
+    }
+    return key;
+};
+
+const missingValue = (state: State, id: number): never => {
+    throw new Error(`An archetype of "${labelOf(state.keys[id])}", a shared component, needs its value.`);
+};
+
+/**
+ * The archetype for sorted component ids, with `values` by component id for the shared ones, the numbers of theirs,
+ * created if needed: values of components it doesn't hold are ignored. Creation allocates, so it happens only at sync
+ * points.
+ */
+export const archetypeOf = (state: State, components: readonly number[], values: readonly (number | undefined)[] = noShared): Archetype => {
+    const key = keyOf(state, components, values);
     const existing = state.archetypeByKey.get(key);
     if (existing !== undefined) return existing;
-    const archetype = createArchetype(state.memory, state.strings, state.archetypes.length, components, state.layouts, components.some(id => state.resources.has(id)), components.some(id => state.meta.has(id)), state.ticked, state.bumped, state.replaced, state.remote);
+    return makeArchetype(state, key, components, values);
+};
+
+/** `archetypeOf` an archetype not found by its key: one of its component set reclaimed and reused, or a new one. */
+const makeArchetype = (state: State, key: string, components: readonly number[], values: readonly (number | undefined)[]): Archetype => {
+    const held: (number | undefined)[] = [];
+    const layouts: (Layout | undefined)[] = [];
+    const texts: (string | undefined)[] = [];
+    for (const id of components) {
+        const interned = state.shared[id];
+        const number = values[id];
+        if (interned === undefined || number === undefined) continue;
+        held[id] = number;
+        layouts[id] = { kind: "constant", value: interned.values[number], shared: true };
+        texts[id] = interned.texts[number];
+    }
+    const shared = held.length === 0 ? noShared : held;
+    const reused = shared === noShared ? null : reuseArchetype(state, key, components, held, layouts, texts);
+    if (reused !== null) {
+        state.archetypeByKey.set(key, reused);
+        return reused;
+    }
+    const archetype = createArchetype(state.memory, state.strings, state.archetypes.length, components, state.layouts, components.some(id => state.resources.has(id)), state.ticked, state.bumped, state.replaced, state.remote, shared, layouts, texts, key);
+    for (const id of components) {
+        const number = held[id];
+        const interned = state.shared[id];
+        if (number !== undefined && interned !== undefined) holdShared(interned, number);
+    }
     state.archetypes.push(archetype);
     state.archetypeByKey.set(key, archetype);
     return archetype;
 };
 
+/**
+ * A value a command gives shared component `id` as stored, interned if new, so the sync point finds its number by it;
+ * throws, failing the issuing system, for one not of its type.
+ */
+export const storedShared = (state: State, id: number, value: unknown): unknown => {
+    const values = state.shared[id];
+    const number = values === undefined ? -1 : internShared(values, value);
+    if (values === undefined || number < 0) throw new Error(`"${labelOf(state.keys[id])}", a shared component, isn't given one of its type's values: ${labelOf(value)}.`);
+    return values.values[number];
+};
+
+/**
+ * The number of a value a command gives shared component `id`: one `storedShared` interned as the command was issued.
+ */
+export const sharedNumberOf = (state: State, id: number, value: unknown): number => {
+    const values = state.shared[id];
+    const number = values === undefined ? -1 : internShared(values, value);
+    if (number < 0) throw new Error(`A command gives "${labelOf(state.keys[id])}", a shared component, ${labelOf(value)}, which isn't one of its type's values.`);
+    return number;
+};
+
+/**
+ * The archetype with value number `number` of shared component `id`, in place of its own or added, through a cached
+ * edge. Creating one allocates, so this runs only at sync points.
+ */
+export const withShared = (state: State, archetype: Archetype, id: number, number: number): Archetype => {
+    if (archetype.shared[id] === number) return archetype;
+    const edges = archetype.sharing[id] ??= [];
+    let next = edges[number];
+    if (next === undefined) {
+        const values = [...archetype.shared];
+        values[id] = number;
+        const components = archetype.storageById[id] === undefined ? [...archetype.components, id].sort((a, b) => a - b) : archetype.components;
+        next = archetypeOf(state, components, values);
+        edges[number] = next;
+        noteEdge(edges, number, undefined, archetype, next);
+    }
+    return next;
+};
+
 /** Starts keeping ticks for components, in every archetype. Allocates, so it runs only between runs. */
 export const startTicking = (state: State, components: readonly number[]): void => {
     for (const id of components) {
@@ -481,8 +636,9 @@ export const withComponent = (state: State, archetype: Archetype, id: number): A
     if (archetype.storageById[id] !== undefined) return archetype;
     let next = archetype.adding[id];
     if (next === undefined) {
-        next = archetypeOf(state, [...archetype.components, id].sort((a, b) => a - b));
+        next = archetypeOf(state, [...archetype.components, id].sort((a, b) => a - b), archetype.shared);
         archetype.adding[id] = next;
+        noteEdge(archetype.adding, id, undefined, archetype, next);
     }
     return next;
 };
@@ -491,8 +647,9 @@ export const withoutComponent = (state: State, archetype: Archetype, id: number)
     if (archetype.storageById[id] === undefined) return archetype;
     let next = archetype.removing[id];
     if (next === undefined) {
-        next = archetypeOf(state, archetype.components.filter(component => component !== id));
+        next = archetypeOf(state, archetype.components.filter(component => component !== id), archetype.shared);
         archetype.removing[id] = next;
+        noteEdge(archetype.removing, id, undefined, archetype, next);
     }
     return next;
 };

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

@@ -1,4 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Finalizer } from '../../interface/finalizer/created.js';
+import { viewsOf, type Layout } from '../../interface/registry/layout.js';
 import type { Memory } from './memory.js';
 import type { StringStore } from './strings.js';
 import { logFinalizedWord, logStopsWord, type MoveLog } from './move-log.js';
@@ -11,7 +13,9 @@ import { logFinalizedWord, logStopsWord, type MoveLog } from './move-log.js';
 // 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.
+// string, the handle of a copy of its record; then its resources as they were before apply: the handle of a copy of
+// each string resource it reads (u32), then each linear resource it reads in its layout, each on 8 bytes. Copies of
+// records are freed with the block, since the thread may read them sync points later.
 
 export const blockSyncWord = 0;
 export const blockNextWord = 1;
@@ -36,11 +40,29 @@ export const valuesAt = (group: number, count: number, objects: number): number
 /** 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 => {
+/**
+ * Where each linear resource's copy starts past a group's columns, after the handles of `strings` string resources,
+ * for linear resources of `strides` bytes; then the bytes of them all.
+ */
+export const resourceOffsetsOf = (strings: number, strides: readonly number[]): number[] => {
+    const offsets: number[] = [];
+    let at = align(4 * strings);
+    for (const stride of strides) {
+        offsets.push(at);
+        at += align(stride);
+    }
+    offsets.push(at);
+    return offsets;
+};
+
+/**
+ * Bytes of a group of `count` stops of a finalizer reading `objects` objects, linear values of `strides` bytes and
+ * `resources` bytes of resources.
+ */
+const groupBytes = (count: number, objects: number, strides: readonly number[], resources: number): number => {
     let bytes = valuesAt(0, count, objects);
     for (const stride of strides) bytes += columnBytes(count, stride);
-    return bytes;
+    return bytes + resources;
 };
 
 /** One of a joined thread's finalizers, as the world writes its stops. */
@@ -54,6 +76,18 @@ export type StopsOf = {
     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[];
+    /**
+     * The string resources it reads, then its linear resources with their strides, in its context's order, which each
+     * group holds copies of; and where each linear one's copy starts past the group's columns, then their bytes.
+     */
+    readonly stringResources: readonly number[];
+    readonly linearResources: readonly number[];
+    readonly resourceStrides: readonly number[];
+    readonly resourceOffsets: readonly number[];
+    /** What its string and linear resources start at, with the linear ones' layouts, for one the world doesn't hold. */
+    readonly stringStarts: readonly unknown[];
+    readonly linearStarts: readonly unknown[];
+    readonly resourceLayouts: readonly Layout[];
     /** This sync point's stops, as plan entries, reused by every sync point. */
     readonly entries: number[];
 };
@@ -127,7 +161,10 @@ const copyStrings = (strings: StringStore, copied: number[], u32: Uint32Array, a
 /** 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. */
+/**
+ * What a sync point's stops come from: entries' entities and archetypes before apply, the entity table's rows, and the
+ * resource entity's archetype and row, -1 without one.
+ */
 export type StopSource = {
     readonly entity: Float64Array;
     readonly from: Int32Array;
@@ -135,6 +172,8 @@ export type StopSource = {
     readonly archetypes: readonly { readonly storageById: readonly (Copied | undefined)[] }[];
     readonly row: Uint32Array;
     readonly holds: Holds;
+    readonly resourceArchetype: number;
+    readonly resourceRow: number;
 };
 
 /**
@@ -146,7 +185,7 @@ export const writeStops = (writer: StopWriter, sync: number, source: StopSource)
     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);
+    for (const stops of staged) bytes += groupBytes(stops.entries.length, stops.objects.length, stops.strides, stops.resourceOffsets[stops.linearResources.length]);
     const offset = memory.allocate(bytes);
     const buffer = memory.memory.buffer;
     const u8 = new Uint8Array(buffer);
@@ -162,9 +201,9 @@ export const writeStops = (writer: StopWriter, sync: number, source: StopSource)
     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 { entries, objects, linear, strides, copies, stringResources, linearResources, resourceStrides, resourceOffsets } = stops;
         const count = entries.length;
-        const size = groupBytes(count, objects.length, strides);
+        const size = groupBytes(count, objects.length, strides, resourceOffsets[linearResources.length]);
         u32[(group >> 2) + groupIndexWord] = stops.index;
         u32[(group >> 2) + groupCountWord] = count;
         u32[(group >> 2) + groupBytesWord] = size;
@@ -228,6 +267,36 @@ export const writeStops = (writer: StopWriter, sync: number, source: StopSource)
             }
             column += columnBytes(count, stride);
         }
+        // As before apply, as its components are: the thread may read them after the resources are written again.
+        if (stringResources.length > 0 || linearResources.length > 0) {
+            const { strings } = writer;
+            const { resourceRow } = source;
+            const storageById = source.resourceArchetype < 0 ? undefined : archetypes[source.resourceArchetype].storageById;
+            for (let k = 0; k < stringResources.length; k++) {
+                const handles = storageById?.[stringResources[k]]?.views.u32;
+                // Without the resource, unreachable while a finalizer activates only once its resources exist: its start.
+                const start = stops.stringStarts[k];
+                const copy = strings === null ? 0 : handles !== undefined ? strings.copy(handles[resourceRow]) : typeof start === "string" ? strings.write(start) : 0;
+                if (copy !== 0) copied.push(copy);
+                u32[(column >> 2) + k] = copy;
+            }
+            for (let k = 0; k < linearResources.length; k++) {
+                const values = storageById?.[linearResources[k]]?.views;
+                const stride = resourceStrides[k];
+                const target = column + resourceOffsets[k];
+                if (values === undefined) {
+                    // Unreachable while a finalizer activates only once its resources exist: its start.
+                    const layout = stops.resourceLayouts[k];
+                    if (layout.kind === "linear") layout.write(viewsOf(buffer, target, stride), 0, stops.linearStarts[k]);
+                    continue;
+                }
+                if ((stride & 3) === 0) {
+                    const words = stride >> 2;
+                    for (let w = 0; w < words; w++) u32[(target >> 2) + w] = values.u32[resourceRow * words + w];
+                }
+                else for (let b = 0; b < stride; b++) u8[target + b] = values.u8[resourceRow * stride + b];
+            }
+        }
         stopped.push([stops.finalizer, count]);
         group += size;
         entries.length = 0;
@@ -283,7 +352,7 @@ export const settleStops = (writer: StopWriter, holds: Holds, released: number[]
 
 /**
  * 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.
+ * failure of the next sync point's run.
  */
 export const endStops = (writer: StopWriter, holds: Holds, released: number[], label: string): { readonly finalizer: Finalizer; readonly error: Error; readonly kind: "thread" }[] => {
     settleStops(writer, holds, released);

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

@@ -1,12 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 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");
@@ -23,60 +21,54 @@ declare module "@adobe/ecs" {
         [note]: { type: string | null };
     }
     export interface Resources {
-        [mode]: { type: "edit" | "view" };
+        [mode]: { type: "edit" | "view"; default: "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 }) => {
+const spawn = System.create({}, ({ commands }, input: { readonly count: number; readonly from: number }) => {
     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 }) => {
+const spawnLong = System.create({}, ({ commands }, input: { readonly count: number }) => {
     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 pass = System.create({ components: { with: [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 }) => {
+const rename = System.create({ components: { with: [order, label] } }, (row, _context, input: { readonly suffix: string }) => {
     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 }) => {
+const relabel = System.create({ components: { with: [order, label] } }, (row, { commands }, input: { readonly suffix: string }) => {
     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 => {
+const tag = System.create({ components: { with: [label] } }, (row, { commands }) => commands.add(row.entity, tagged));
+const untag = System.create({ components: { with: [tagged] } }, (row, { commands }) => commands.remove(row.entity, tagged));
+const unlabel = System.create({ components: { with: [label] } }, (row, { commands }) => commands.remove(row.entity, label));
+const despawn = System.create({ components: { with: [order] } }, (row, { commands }) => commands.despawn(row.entity));
+const annotate = System.create({ components: { with: [order, note] } }, row => {
     row[note] = row[order] % 3 === 0 ? null : `note ${row[order]}`;
 });
-const unannotate = System.create({ name: "stringsTest/unannotate", components: { write: [note] } }, row => {
+const unannotate = System.create({ components: { with: [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 }) => {
+const noted = System.create({ components: { with: [order], not: [note] } }, (row, { commands }) => commands.add(row.entity, note, null));
+const despawnEven = System.create({ components: { with: [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 }) => {
+const labelAgain = System.create({ components: { with: [order], not: [label] } }, (row, { commands }, input: { readonly suffix: string }) => {
     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 }) => {
+const edit = System.create({}, ({ resources }, input: { readonly title: string }) => {
     resources[mode] = "edit";
     resources[title] = input.title;
 });
@@ -126,15 +118,13 @@ describe("strings", () => {
     });
     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 sharing = world.share(channel.port1);
+        const remote = await join(channel.port2, { threads: [] });
+        await sharing;
         const shared = await arena(world);
         expect(shared - alone).toBeGreaterThan(1000 * 1024);
         await remote.dispose();
@@ -158,10 +148,9 @@ describe("strings", () => {
         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);
+        const shared = world.share(channel.port1);
+        const remote = await join(channel.port2, { threads: [] });
+        await shared;
         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]> => {

package/src/implementation/world/strings.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { coveringBuffer, type Memory } from './memory.js';
 
 // Strings in shared memory (design.md, "A string's storage"): a string component's column holds a handle per row, to