@adobe/ecs 0.1.0 → 0.2.1

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

@@ -1,9 +1,9 @@
-import { Component } from "../../interface/component/component.js";
-import { Resource } from "../../interface/resource/resource.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { System } from "../../interface/system/system.js";
 import { readResource } from "./reads.test-helper.js";
 import { createWorld } from "./create.js";
 import { workers } from "../../interface/resources/workers.js";
+import type { F32 } from "../../interface/math/index.js";
 
 /** Scenarios of reductions across workers, run built in node and from source in chromium. */
 
@@ -15,7 +15,7 @@ const largest = Symbol("reductionsBrowserTest/largest");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [weight]: { type: number };
+        [weight]: { type: F32 };
         [sized]: { type: true };
     }
     export interface Resources {
@@ -25,23 +25,18 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(weight, { type: { type: "number", precision: 1 } });
-Component.register(sized, { type: { const: true } });
-Resource.register(count, { type: { type: "number", default: 0 }, reduce: "+" });
-Resource.register(sum, { type: { type: "number", default: 0 }, reduce: "+" });
-Resource.register(largest, { type: { type: "number", default: 0 }, reduce: "max" });
 
 export const rows = 100_000;
 export const weightAt = (i: number): number => Math.fround(Math.sin(i * 0.37) * 1000);
 
-const spawn = System.create({ name: "reductionsBrowserTest/spawn" }, ({ commands }) => {
+const spawn = System.create({}, ({ commands }) => {
     for (let i = 0; i < rows; i++) {
         if (i % 4 === 0) commands.spawn([weight, sized])({ [weight]: weightAt(i), [sized]: true });
         else commands.spawn([weight])({ [weight]: weightAt(i) });
     }
 });
 
-const reduce = System.create({ name: "reductionsBrowserTest/reduce", kernel: "cpu", components: { read: [weight] }, reduce: { [count]: "+", [sum]: "+", [largest]: "max" } }, (row, { reduce }) => {
+const reduce = System.create({ kernel: true, components: { with: [weight] } }, (row, { reduce }) => {
     reduce[count](1);
     reduce[sum](row[weight]);
     reduce[largest](row[weight]);

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

@@ -1,7 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component } from "../../interface/component/component.js";
-import { Vec3 } from "../../interface/math/index.js";
-import { Resource } from "../../interface/resource/resource.js";
+import { type I32, type U32, Vec3 } from "../../interface/math/index.js";
+import { registerResource } from "../../interface/registry/declarations.js";
 import { System } from "../../interface/system/system.js";
 import { createWorld } from "./create.js";
 import { readResource } from "./reads.test-helper.js";
@@ -9,8 +9,9 @@ import { definitionOf } from "../../interface/registry/index.js";
 import type { Name } from "../../interface/system/name.js";
 import { createRegistrar } from "./register.js";
 import { createState } from "./state.js";
+import { giveAccess } from "../../interface/registry/ids.test-helper.js";
 import { workers } from "../../interface/resources/workers.js";
-import { runReported } from "./reports.test-helper.js";
+import { runReported } from "./outcomes.test-helper.js";
 
 const position = Symbol("reductionsTest/position");
 const mass = Symbol("reductionsTest/mass");
@@ -28,47 +29,34 @@ const summed = Symbol("reductionsTest/summed");
 declare module "@adobe/ecs" {
     export interface Components {
         [position]: { type: Vec3 };
-        [mass]: { type: number };
+        [mass]: { type: U32 };
         [heavy]: { type: true };
     }
     export interface Resources {
         [total]: { type: number; reduce: "+" };
-        [low]: { type: readonly [number, number, number]; reduce: "min" };
-        [bits]: { type: number; reduce: "|" };
-        [least]: { type: number; reduce: "min" };
+        [low]: { type: Vec3; reduce: "min" };
+        [bits]: { type: U32; reduce: "|" };
+        [least]: { type: U32; reduce: "min" };
         [any]: { type: boolean; reduce: "|" };
         [level]: { type: number };
         [seen]: { type: number };
-        [wrapped]: { type: number; reduce: "+" };
-        [summed]: { type: boolean; reduce: "|" };
+        [wrapped]: { type: I32; default: 5; reduce: "+" };
     }
 }
 
-Component.register(position, { type: Vec3.schema });
-Component.register(mass, { type: { type: "integer", minimum: 0, maximum: 0xFFFFFFFF } });
-Component.register(heavy, { type: { const: true } });
-Resource.register(total, { type: { type: "number", default: 0 }, reduce: "+" });
-Resource.register(low, { type: { ...Vec3.schema, default: [0, 0, 0] }, reduce: "min" });
-Resource.register(bits, { type: { type: "integer", minimum: 0, maximum: 0xFFFFFFFF, default: 0 }, reduce: "|" });
-Resource.register(least, { type: { type: "integer", minimum: 0, maximum: 0xFFFFFFFF, default: 0 }, reduce: "min" });
-Resource.register(any, { type: { type: "boolean", default: false }, reduce: "|" });
-Resource.register(level, { type: { type: "number", default: 0 } });
-Resource.register(seen, { type: { type: "number", default: 0 } });
-Resource.register(wrapped, { type: { type: "integer", minimum: -(2 ** 31), maximum: 2 ** 31 - 1, default: 5 }, reduce: "+" });
-
 const rows = 3000;
 const positionAt = (i: number): Vec3 => [Math.sin(i) * 100, (i % 97) - 50, i / 7];
 const massAt = (i: number): number => (i * 2654435761) >>> 20;
 
 /** Rows in two archetypes, so a run folds more than one call's partials. */
-const spawn = System.create({ name: "reductionsTest/spawn" }, ({ commands }) => {
+const spawn = System.create({}, ({ commands }) => {
     for (let i = 0; i < rows; i++) {
         if (i % 3 === 0) commands.spawn([position, mass, heavy])({ [position]: positionAt(i), [mass]: massAt(i), [heavy]: true });
         else commands.spawn([position, mass])({ [position]: positionAt(i), [mass]: massAt(i) });
     }
 });
 
-const kernel = System.create({ name: "reductionsTest/kernel", kernel: "cpu", components: { read: [position, mass] }, reduce: { [total]: "+", [low]: "min", [bits]: "|", [least]: "min" } }, (row, { reduce }) => {
+const kernel = System.create({ kernel: true, components: { with: [position, mass] } }, (row, { reduce }) => {
     const [x, y, z] = row[position];
     reduce[total](row[mass]);
     reduce[total](0.5);
@@ -78,7 +66,7 @@ const kernel = System.create({ name: "reductionsTest/kernel", kernel: "cpu", com
 });
 
 /** The same reductions, run as written on the main thread. */
-const body = System.create({ name: "reductionsTest/body", components: { read: [position, mass] }, reduce: { [total]: "+", [low]: "min", [bits]: "|", [least]: "min" } }, (row, { reduce }) => {
+const body = System.create({ components: { with: [position, mass] } }, (row, { reduce }) => {
     const [x, y, z] = row[position];
     reduce[total](row[mass]);
     reduce[total](0.5);
@@ -87,29 +75,29 @@ const body = System.create({ name: "reductionsTest/body", components: { read: [p
     reduce[least](row[mass]);
 });
 
-const filtered = System.create({ name: "reductionsTest/filtered", kernel: "cpu", components: { read: [mass], has: [heavy] }, resources: { changed: [level] }, reduce: { [total]: "+", [least]: "min" } }, (row, { reduce }) => {
+const filtered = System.create({ kernel: true, components: { with: [mass, heavy] }, resources: { changed: [level] } }, (row, { reduce }) => {
     reduce[total](row[mass]);
     reduce[least](row[mass]);
 });
 
-const flags = System.create({ name: "reductionsTest/flags", kernel: "cpu", components: { read: [mass] }, reduce: { [any]: "|" } }, (row, { reduce }) => {
+const flags = System.create({ kernel: true, components: { with: [mass] } }, (row, { reduce }) => {
     reduce[any](row[mass] > 4000);
 });
 
 /** Two contributors to `total`, the heavy rows and the light ones, and a reader of the finished fold. */
-const heavyMass = System.create({ name: "reductionsTest/heavy", kernel: "cpu", components: { read: [mass], has: [heavy] }, reduce: { [total]: "+" } }, (row, { reduce }) => {
+const heavyMass = System.create({ kernel: true, components: { with: [mass, heavy] } }, (row, { reduce }) => {
     reduce[total](row[mass]);
 });
-const lightMass = System.create({ name: "reductionsTest/light", components: { read: [mass], not: [heavy] }, reduce: { [total]: "+" } }, (row, { reduce }) => {
+const lightMass = System.create({ components: { with: [mass], not: [heavy] } }, (row, { reduce }) => {
     reduce[total](row[mass]);
 });
-const reader = System.create({ name: "reductionsTest/reader", resources: { read: [total], write: [seen] } }, ({ resources }) => {
+const reader = System.create({}, ({ resources }) => {
     resources[seen] = resources[total];
 });
-const frame = System.create({ name: "reductionsTest/frame", systems: [reader, heavyMass, lightMass] });
+const frame = System.create({ systems: [reader, heavyMass, lightMass] });
 
-const weigh = System.create({ name: "reductionsTest/weigh", components: { write: [mass], has: [heavy] } }, row => { row[mass] = 1; });
-const kernelChanged = System.create({ name: "reductionsTest/changed", kernel: "cpu", components: { read: [mass], changed: [mass] }, reduce: { [total]: "+" } }, (row, { reduce }) => {
+const weigh = System.create({ components: { with: [mass, heavy] } }, row => { row[mass] = 1; });
+const kernelChanged = System.create({ kernel: true, components: { with: [mass], changed: [mass] } }, (row, { reduce }) => {
     reduce[total](row[mass]);
 });
 
@@ -170,7 +158,7 @@ describe("reductions", () => {
 
     it("keep the previous value when a contributor fails, or when every contributor skips the run", async () => {
         let fail = false;
-        const fails = System.create({ name: "reductionsTest/fails", components: { read: [mass], has: [heavy] }, reduce: { [total]: "+" } }, (row, { reduce }) => {
+        const fails = System.create({ components: { with: [mass, heavy] } }, (row, { reduce }) => {
             reduce[total](row[mass]);
             if (fail) throw new Error("contributor failed");
         });
@@ -213,7 +201,7 @@ describe("reductions", () => {
 
     it("stamp their resources changed only when the fold differs", async () => {
         let ran = 0;
-        const watcher = System.create({ name: "reductionsTest/reader/2", components: { has: [mass] }, resources: { changed: [total] } }, () => { ran++; });
+        const watcher = System.create({ components: { with: [mass] }, resources: { changed: [total] } }, () => { ran++; });
         const world = createWorld({ [workers]: 0 });
         await world.run(spawn);
         await world.run(kernel);
@@ -227,7 +215,7 @@ describe("reductions", () => {
     });
 
     it("store an infinite sum as any write of it, and only an empty min or max as the integer type's extreme", async () => {
-        const infinite = System.create({ name: "reductionsTest/infinite", components: { has: [mass] }, reduce: { [wrapped]: "+" } }, (_, { reduce }) => {
+        const infinite = System.create({ components: { with: [mass] } }, (_, { reduce }) => {
             reduce[wrapped](Infinity);
         });
         const world = createWorld({ [workers]: 0 });
@@ -246,26 +234,25 @@ describe("reductions", () => {
     });
 
     it("reject what can't be reduced", async () => {
-        // @ts-expect-error booleans reduce bitwise
-        expect(() => Resource.register(summed, { type: { type: "boolean", default: false }, reduce: "+" })).toThrow(`booleans reduce with "&", "|" or "^"`);
-        // @ts-expect-error a contributor repeats its resource's operator
-        expect(() => System.create({ name: "reductionsTest/other", components: { has: [mass] }, reduce: { [total]: "max" } }, (_, { reduce }) => { reduce[total](1); })).toThrow(`reduces "reductionsTest/total" with "max", but it's declared reduce: "+"`);
+        // Booleans reduce bitwise.
+        expect(() => registerResource(summed, { type: { type: "boolean" }, default: false, reduce: "+" })).toThrow(`booleans reduce with "&", "|" or "^"`);
         // @ts-expect-error only a resource with a reduce trait is reduced
-        expect(() => System.create({ name: "reductionsTest/other/2", components: { has: [mass] }, reduce: { [level]: "+" } }, (_, { reduce }) => { reduce[level](1); })).toThrow(`reduces "reductionsTest/level", which has no reduce trait`);
+        expect(() => System.create({ components: { with: [mass] } }, (_, { reduce }) => { reduce[level](1); })).toThrow(`reduces "reductionsTest/level", which has no reduce trait`);
         // @ts-expect-error a reduced resource is never written
-        expect(() => System.create({ name: "reductionsTest/other/3", resources: { write: [total] } }, ({ resources }) => { resources[total] = 1; })).toThrow(`writes "reductionsTest/total", which is reduced`);
-        // @ts-expect-error a contributor doesn't read what it reduces into
-        expect(() => System.create({ name: "reductionsTest/other/4", components: { has: [mass] }, resources: { read: [total] }, reduce: { [total]: "+" } }, (_, { resources, reduce }) => { reduce[total](resources[total]); })).toThrow(`reduces "reductionsTest/total", so it can't also read, write or filter on it`);
-        // @ts-expect-error nor filters on it
-        expect(() => System.create({ name: "reductionsTest/other/5", components: { has: [mass] }, resources: { changed: [total] }, reduce: { [total]: "+" } }, (_, { reduce }) => { reduce[total](1); })).toThrow(`reduces "reductionsTest/total", so it can't also read, write or filter on it`);
+        expect(() => System.create({}, ({ resources }) => { resources[total] = 1; })).toThrow(`writes "reductionsTest/total", which is reduced`);
+        // A contributor doesn't read what it reduces into.
+        expect(() => System.create({ components: { with: [mass] } }, (_, { resources, reduce }) => { reduce[total](resources[total]); })).toThrow(`reduces "reductionsTest/total", so it can't also read, write or filter on it`);
+        // Nor filters on it.
+        expect(() => System.create({ components: { with: [mass] }, resources: { changed: [total] } }, (_, { reduce }) => { reduce[total](1); })).toThrow(`reduces "reductionsTest/total", so it can't also read, write or filter on it`);
     });
 
     it("leave nothing subscribed to sync points from a registration that failed", () => {
         const state = createState(true);
         const registrar = createRegistrar(state);
-        // A declaration the build doesn't see is a kernel it didn't compile, which only a world's registration finds.
-        const uncompiled = { name: "reductionsTest/other/6", kernel: "cpu", components: { read: [mass] } } as const;
-        const both = System.create({ name: "reductionsTest/both", systems: [kernel, System.create(uncompiled, row => { void row[mass]; })] });
+        // A call the build doesn't see is a kernel it didn't compile, which only a world's registration finds.
+        const unseen = System.create;
+        const uncompiled = giveAccess({ kernel: true, components: { with: [mass] } } as const, { read: [mass] });
+        const both = System.create({ systems: [kernel, unseen(uncompiled, row => { void row[mass]; })] });
         const definition = (system: System<unknown>) => {
             const found = definitionOf(system);
             if (found === undefined) throw new Error("not a system");

package/src/implementation/world/reductions.ts

@@ -1,12 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Reduction } from '../../interface/resource/reduction.js';
-import type { Declaration } from '../../interface/system/declaration.js';
+import type { Resolved } from '../../interface/system/declaration.js';
 import { isReduction } from '../../interface/registry/reduction.js';
 import type { Layout, Path, View } from '../../interface/registry/layout.js';
 import { stampChanged } from './archetype.js';
 import { readCell, writeCell } from './cells.js';
 import { resourceCell } from './resources.js';
 import { idOf, type Key, type State } from './state.js';
-import { labelOf } from '../../interface/registry/index.js';
+import { declarationOf, labelOf } from '../../interface/registry/index.js';
 
 /** A resource a system reduces into: its operator, and the scalar leaves of its value. */
 export type ReductionTarget = {
@@ -19,18 +20,19 @@ const bitwise: ReadonlySet<Reduction> = new Set(["&", "|", "^"]);
 
 
 /**
- * The resources a declaration reduces into, with their layouts' leaves. Creating the system checked each against its
- * `reduce` trait, which registering the resource checked against its schema, so a throw here is an invariant broken.
+ * The resources a system reduces into, with their operators, their `reduce` traits, and their layouts' leaves.
+ * Creating the system checked each has a trait, which registering the resource checked against its schema, so a throw
+ * here is an invariant broken.
  */
-export const reductionTargets = (state: State, declaration: Pick<Declaration, "name" | "reduce">): readonly ReductionTarget[] =>
-    reductionTargetsOf(key => state.layouts[idOf(state, key)], declaration);
+export const reductionTargets = (state: State, name: string, declaration: Resolved): readonly ReductionTarget[] =>
+    reductionTargetsOf(key => state.layouts[idOf(state, key)], name, declaration);
 
-/** The resources a declaration reduces into, by `layoutFor`, each resource's layout. */
-export const reductionTargetsOf = (layoutFor: (key: Key) => Layout | undefined, { name, reduce }: Pick<Declaration, "name" | "reduce">): readonly ReductionTarget[] => {
+/** The resources a system `name` reduces into, by `layoutFor`, each resource's layout. */
+export const reductionTargetsOf = (layoutFor: (key: Key) => Layout | undefined, name: string, declaration: Resolved): readonly ReductionTarget[] => {
+    const reduce = declaration.resources?.reduce;
     if (reduce === undefined) return [];
-    return Object.getOwnPropertySymbols(reduce).flatMap((key): ReductionTarget[] => {
-        const operator: unknown = Reflect.get(reduce, key);
-        if (operator === undefined) return [];
+    return reduce.map((key): ReductionTarget => {
+        const operator: unknown = declarationOf(key)?.reduce;
         if (!isReduction(operator)) throw new Error(`System "${name}" reduces "${labelOf(key)}" with "${labelOf(operator)}", which isn't an operator.`);
         const layout = layoutFor(key);
         if (layout?.kind !== "linear") throw new Error(`System "${name}" reduces "${labelOf(key)}", which isn't stored in linear memory.`);
@@ -38,7 +40,7 @@ export const reductionTargetsOf = (layoutFor: (key: Key) => Layout | undefined,
         if (leaves.some(leaf => leaf.boolean) && !bitwise.has(operator)) {
             throw new Error(`System "${name}" reduces "${labelOf(key)}", which has boolean values, with "${operator}"; booleans reduce with "&", "|" or "^".`);
         }
-        return [{ key, operator, leaves }];
+        return { key, operator, leaves };
     });
 };
 

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

@@ -1,4 +1,5 @@
-import { Component, System } from "../../index.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { System } from "../../index.js";
 
 // A module the identity example evaluates twice, as a dev server does after an edit.
 export const score = Symbol("reevaluation/score");
@@ -9,8 +10,7 @@ declare module "@adobe/ecs" {
     }
 }
 
-Component.register(score, { type: { type: "number" } });
 
-export const bump = System.create({ name: "reevaluation/bump", components: { write: [score] } }, row => {
+export const bump = System.create({ components: { with: [score] } }, row => {
     row[score] += 1;
 });

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

@@ -1,21 +1,22 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { expect, it } from "vitest";
 import { System } from "../../index.js";
 import { Observe } from "../../observe/index.js";
 import { bump, score } from "./reevaluation.test-helper.js";
 import { createWorld } from "../index.js";
-import { runReported } from "./reports.test-helper.js";
+import { runReported } from "./outcomes.test-helper.js";
 
-const spawn = System.create({ name: "reevaluation/spawn" }, ({ commands }) => { commands.spawn([score])({ [score]: 0 }); });
+const spawn = System.create({}, ({ commands }) => { commands.spawn([score])({ [score]: 0 }); });
 
-// A name is a label, so other code may use it too: this isn't 20-score.ts's `bump`, and reports label the two apart.
-const broken = System.create({ name: "reevaluation/bump" }, () => {
+// A label isn't an identity: this `bump` isn't the helper's, and reports tell the two apart by their ids.
+const bump2 = System.create({}, () => {
     throw new Error("offline");
 });
 
-it("labels systems that share a name by their ids", async () => {
+it("gives each system's id beside its label", async () => {
     await using world = createWorld();
-    const { failures } = await runReported(world, broken);
-    expect(failures.map(({ name }) => name)).toEqual(["reevaluation/bump (@adobe/ecs/src/implementation/world/reevaluation.test.ts#broken)"]);
+    const { failures } = await runReported(world, bump2);
+    expect(failures.map(({ name, id }) => [name, id])).toEqual([["bump2", expect.stringMatching(/^@adobe\/ecs@[^/]+\/src\/implementation\/world\/reevaluation\.test\.ts#bump2$/)]]);
 });
 
 it("matches the keys and systems of a module evaluated again by id", async () => {
@@ -26,7 +27,7 @@ it("matches the keys and systems of a module evaluated again by id", async () =>
     const path = "./reevaluation.test-helper.js?again";
     const again: typeof import("./reevaluation.test-helper.js") = await import(/* @vite-ignore */ path);
     // Its key is the same component, and its system the same system, so a composite holds it once.
-    await world.run(System.create({ name: "reevaluation/both", systems: [bump, again.bump] }));
+    await world.run(System.create({ systems: [bump, again.bump] }));
     const [entity] = await Observe.toPromise(Observe.select(world, { required: [again.score] }));
     expect((await Observe.toPromise(Observe.entity(world, entity, { required: [again.score] })))?.[again.score]).toBe(2);
 });

package/src/implementation/world/register.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Leaf } from '../../interface/system/leaf.js';
 import { idOfItem, idOfKey, labelOf, requireDefinition, threadOf, type Definition } from '../../interface/registry/index.js';
 import { createRemoteRunner, unplaceable } from './remote-systems.js';
@@ -5,7 +6,7 @@ import { createJoinedObserverRunner, type ObserverTarget } from './joined-observ
 import { createRunner, releaseHoldings, removedRunner, stopHoldings, type Holdings, type Runner } from './runner.js';
 import { isLeaf, reducedBy, scheduleOf, type Schedule } from '../../interface/registry/schedule.js';
 import { idOf, observe, unobserve, type Key, type State } from './state.js';
-import { labelOfItem, orderKeysOf } from '../../interface/registry/index.js';
+import { orderKeysOf } from '../../interface/registry/index.js';
 import { entityWatchesOf, indexWatchesOf, lookupComponentsOf, orderComponentsOf } from './lookup-keys.js';
 
 /** What a registration still has to do asynchronously: add resources, then load kernels; `rollback` undoes it if that fails. */
@@ -377,7 +378,7 @@ export const createRegistrar = (state: State): Registrar => {
             if (problem !== null) return;
             const thread = threadOf(leaf.declaration, "System", leaf.name);
             if (thread === null || !threads.includes(thread)) return;
-            const label = labelOfItem(leaf);
+            const label = leaf.name;
             const id = idOfItem(leaf);
             if (id === undefined) problem = `System "${label}" runs on thread "${thread}" and has no id, so a joined thread can't run it; the build gives top-level systems one.`;
             else if (!imported.has(id)) problem = `System "${label}" runs on thread "${thread}", which the joined thread claiming it never imported.`;

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

@@ -1,11 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { MessagePort as NodeMessagePort } from "node:worker_threads";
 import { join } from "./create.js";
 import { scopeChannel } from "./port.js";
-import { entitled, released, type Released } from "./remote-finalizers.test-helper.js";
+import { entitled, gauged, headlined, headlinedBoth, released, surveyed, type Released, type Surveyed } from "./remote-finalizers.test-helper.js";
 
 /**
  * A thread joining a world through the port it's sent, claiming "remoteFinalizersTest", whose finalizer it imports: it
- * tells what its finalizers saw when asked, or spins, without yielding, for a while or for good.
+ * tells what its finalizers saw when asked, blocks until a shared flag is set, or spins, without yielding, for good.
  */
 
 type Port = MessagePort | NodeMessagePort;
@@ -13,28 +14,42 @@ export type ToRemoteFinalizersWorker =
     | { readonly kind: "join"; readonly port: Port }
     | { readonly kind: "released" }
     | { readonly kind: "entitled" }
-    | { readonly kind: "pause"; readonly milliseconds: number }
+    | { readonly kind: "headlined" }
+    | { readonly kind: "gauged" }
+    | { readonly kind: "hold"; readonly flag: Int32Array }
     | { readonly kind: "spin" };
 export type FromRemoteFinalizersWorker =
     | { readonly kind: "joined" }
     | { readonly kind: "released"; readonly released: readonly Released[] }
     | { readonly kind: "entitled"; readonly entitled: readonly { readonly serial: number; readonly title: string }[] }
+    | {
+        readonly kind: "headlined";
+        readonly headlined: readonly { readonly serial: number; readonly heading: string }[];
+        readonly both: readonly { readonly serial: number; readonly heading: string; readonly subheading: string }[];
+    }
+    | {
+        readonly kind: "gauged";
+        readonly gauged: readonly { readonly serial: number; readonly level: number; readonly origin: readonly number[] }[];
+        readonly surveyed: readonly Surveyed[];
+    }
+    | { readonly kind: "held" }
     | { readonly kind: "spinning" };
 
 const channel = scopeChannel<FromRemoteFinalizersWorker, ToRemoteFinalizersWorker>();
-channel.onMessage(message => {
+channel.onMessage(async message => {
     if ("protocol" in message) return;
     if (message.kind === "join") {
-        join(message.port, { threads: ["remoteFinalizersTest"] });
+        await join(message.port, { threads: ["remoteFinalizersTest"] });
         channel.post({ kind: "joined" });
     }
     else if (message.kind === "released") channel.post({ kind: "released", released });
     else if (message.kind === "entitled") channel.post({ kind: "entitled", entitled });
-    else if (message.kind === "pause") {
-        channel.post({ kind: "spinning" });
-        // Runs nothing meanwhile, finalizers included, then goes on.
-        const until = performance.now() + message.milliseconds;
-        while (performance.now() < until) { /* busy */ }
+    else if (message.kind === "gauged") channel.post({ kind: "gauged", gauged, surveyed });
+    else if (message.kind === "headlined") channel.post({ kind: "headlined", headlined, both: headlinedBoth });
+    else if (message.kind === "hold") {
+        channel.post({ kind: "held" });
+        // Runs nothing, finalizers included, until the flag over shared memory is set.
+        Atomics.wait(message.flag, 0, 0);
     }
     else {
         channel.post({ kind: "spinning" });

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

@@ -1,5 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import type * as Fixture from "./remote-finalizers.fixture.js";
+import { surveyOf } from "./remote-finalizers.test-helper.js";
 
 /** Finalizers on a joined worker: the cases, over the fixture built for node or from source. */
 export const remoteFinalizersCases = (load: () => Promise<typeof Fixture>) => describe("finalizers on a joined worker", () => {
@@ -13,7 +15,7 @@ export const remoteFinalizersCases = (load: () => Promise<typeof Fixture>) => de
         const fixture = await load();
         expect(await fixture.diesHolding()).toEqual({
             held: 3, whileHeld: 0,
-            failures: [["thread", "remoteFinalizersTest/release", 'Thread "remoteFinalizersTest" is gone, so 3 stops of finalizer "remoteFinalizersTest/release" didn\'t run there.']],
+            failures: [["thread", "release", 'Thread "remoteFinalizersTest" is gone, so 3 stops of finalizer "release" didn\'t run there.']],
             after: 3,
         });
     }, 30000);
@@ -21,4 +23,20 @@ export const remoteFinalizersCases = (load: () => Promise<typeof Fixture>) => de
         const fixture = await load();
         expect(await fixture.titledStops()).toEqual(Array.from({ length: 50 }, (_, k) => ({ serial: k, title: `t${k}` })));
     }, 30000);
+    it("read one string resource, or two, as they were before their stops' sync point applied, after the world wrote them again and freed their records", async () => {
+        const fixture = await load();
+        const heading = (k: number): string => k < 10 ? "h0" : "h6";
+        expect(await fixture.headedStops()).toEqual({
+            one: Array.from({ length: 20 }, (_, k) => ({ serial: k, heading: heading(k) })),
+            two: Array.from({ length: 20 }, (_, k) => ({ serial: k, heading: heading(k), subheading: `s${heading(k)}` })),
+        });
+    }, 30000);
+    it("read linear resources of every width, and strings beside them, as they were before their stops' sync point applied, after the world wrote them again", async () => {
+        const fixture = await load();
+        const level = (k: number): number => k < 10 ? 0 : 6;
+        expect(await fixture.gaugedStops()).toEqual({
+            linear: Array.from({ length: 20 }, (_, k) => ({ serial: k, level: level(k), origin: [level(k), level(k) + 10] })),
+            mixed: Array.from({ length: 20 }, (_, k) => ({ serial: k, ...surveyOf(level(k)) })),
+        });
+    }, 30000);
 });

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
 import type { Entity } from "../../interface/entity/entity.js";
 import { Observe } from "../../observe/index.js";
@@ -5,8 +6,8 @@ import { workers } from "../../interface/resources/workers.js";
 import { createWorld, type CreatedWorld } from "./create.js";
 import { indexOf } from "./entities.js";
 import type { FromRemoteFinalizersWorker, ToRemoteFinalizersWorker } from "./remote-finalizers-worker.fixture.js";
-import { despawn, released, retitle, scenario, serial, sorted, spawn, spawnTitled, type Released } from "./remote-finalizers.test-helper.js";
-import { fillReports, runReported } from "./reports.test-helper.js";
+import { despawn, regauge, rehead, released, retitle, scenario, serial, sorted, spawn, spawnHeaded, spawnTitled, type Released, type Surveyed } from "./remote-finalizers.test-helper.js";
+import { runReported } from "./outcomes.test-helper.js";
 
 /**
  * Scenarios of finalizers on a joined worker, run built in node and from source in chromium: the same stops as an
@@ -58,13 +59,23 @@ const until = <T>(observe: Observe<T>, accept: (value: T) => boolean): Promise<T
 /** A world shared with a worker that joins it claiming "remoteFinalizersTest", once it joined. */
 const joined = async (world: CreatedWorld): Promise<{ readonly worker: Worker }> => {
     const { port1, port2 } = new MessageChannel();
-    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 };
 };
 
+/** Holds the worker, which runs nothing until the returned function lets it go on. */
+const hold = async (worker: Worker): Promise<() => void> => {
+    const flag = new Int32Array(new SharedArrayBuffer(4));
+    await worker.ask({ kind: "hold", flag });
+    return () => {
+        Atomics.store(flag, 0, 1);
+        Atomics.notify(flag, 0);
+    };
+};
+
 /** What the worker's finalizer saw. */
 const releasedThere = async (worker: Worker): Promise<readonly Released[]> => {
     const reply = await worker.ask({ kind: "released" });
@@ -93,8 +104,6 @@ export const sameStops = async () => {
  */
 export const diesHolding = async () => {
     const world = createWorld({ [workers]: 0 });
-    // Past the runs that spawn reports, whose entities would take the released indexes first.
-    await fillReports(world);
     const { worker } = await joined(world);
     await world.run(spawn, { from: 0, count: 4 });
     const stopped: Entity[] = [];
@@ -117,7 +126,7 @@ export const diesHolding = async () => {
 };
 
 /**
- * Titled rows despawned while the worker runs nothing, then the world's thread rewriting the titles of others six
+ * Titled rows despawned while the worker is held, then the world's thread rewriting the titles of others six
  * times, so the records the despawned rows' titles were in are freed and reused before the worker finalizes them:
  * the titles its finalizer read.
  */
@@ -125,10 +134,15 @@ export const titledStops = async () => {
     const world = createWorld({ [workers]: 0 });
     const { worker } = await joined(world);
     await world.run(spawnTitled, { from: 0, count: 50 });
-    await worker.ask({ kind: "pause", milliseconds: 300 });
-    await world.run(despawn, { serials: Array.from({ length: 50 }, (_, k) => k) });
-    await world.run(spawnTitled, { from: 100, count: 50 });
-    for (let round = 0; round < 6; round++) await world.run(retitle, { round });
+    const release = await hold(worker);
+    try {
+        await world.run(despawn, { serials: Array.from({ length: 50 }, (_, k) => k) });
+        await world.run(spawnTitled, { from: 100, count: 50 });
+        for (let round = 0; round < 6; round++) await world.run(retitle, { round });
+    }
+    finally {
+        release();
+    }
     let seen: readonly { readonly serial: number; readonly title: string }[] = [];
     for (let k = 0; k < 200 && seen.length < 50; k++) {
         const reply = await worker.ask({ kind: "entitled" });
@@ -138,3 +152,64 @@ export const titledStops = async () => {
     await world.dispose();
     return [...seen].sort((a, b) => a.serial - b.serial);
 };
+
+/**
+ * Headed rows despawned with the heading "h0" while the worker is held, then the world's thread writing the heading
+ * and subheading six times, so the records of "h0" and "sh0" are freed and reused before the worker finalizes them,
+ * and the rest despawned once it goes on: what its finalizers of one and two string resources read.
+ */
+export const headedStops = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { worker } = await joined(world);
+    await world.run(rehead, { heading: "h0" });
+    await world.run(spawnHeaded, { from: 0, count: 20 });
+    const release = await hold(worker);
+    try {
+        await world.run(despawn, { serials: Array.from({ length: 10 }, (_, k) => k) });
+        for (let round = 1; round <= 6; round++) await world.run(rehead, { heading: `h${round}` });
+    }
+    finally {
+        release();
+    }
+    await world.run(despawn, { serials: Array.from({ length: 10 }, (_, k) => 10 + k) });
+    let seen: readonly { readonly serial: number; readonly heading: string }[] = [];
+    let both: readonly { readonly serial: number; readonly heading: string; readonly subheading: string }[] = [];
+    for (let k = 0; k < 200 && (seen.length < 20 || both.length < 20); k++) {
+        const reply = await worker.ask({ kind: "headlined" });
+        seen = reply.kind === "headlined" ? reply.headlined : [];
+        both = reply.kind === "headlined" ? reply.both : [];
+    }
+    await worker.terminate();
+    await world.dispose();
+    return { one: [...seen].sort((a, b) => a.serial - b.serial), two: [...both].sort((a, b) => a.serial - b.serial) };
+};
+
+/**
+ * Headed rows despawned at level 0 while the worker is held, then the world's thread writing the level and origin six
+ * times, with resources of mixed widths, and the rest despawned once it goes on: what its finalizers read.
+ */
+export const gaugedStops = async () => {
+    const world = createWorld({ [workers]: 0 });
+    const { worker } = await joined(world);
+    await world.run(regauge, { level: 0 });
+    await world.run(spawnHeaded, { from: 0, count: 20 });
+    const release = await hold(worker);
+    try {
+        await world.run(despawn, { serials: Array.from({ length: 10 }, (_, k) => k) });
+        for (let round = 1; round <= 6; round++) await world.run(regauge, { level: round });
+    }
+    finally {
+        release();
+    }
+    await world.run(despawn, { serials: Array.from({ length: 10 }, (_, k) => 10 + k) });
+    let seen: readonly { readonly serial: number; readonly level: number; readonly origin: readonly number[] }[] = [];
+    let mixed: readonly Surveyed[] = [];
+    for (let k = 0; k < 200 && (seen.length < 20 || mixed.length < 20); k++) {
+        const reply = await worker.ask({ kind: "gauged" });
+        seen = reply.kind === "gauged" ? reply.gauged : [];
+        mixed = reply.kind === "gauged" ? reply.surveyed : [];
+    }
+    await worker.terminate();
+    await world.dispose();
+    return { linear: [...seen].sort((a, b) => a.serial - b.serial), mixed: [...mixed].sort((a, b) => a.serial - b.serial) };
+};