@adobe/ecs 0.1.0 → 0.2.1

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

@@ -1,14 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import { Observe } from "../../observe/index.js";
 import { always } from "../../interface/resources/always.js";
-import { Report } from "../../interface/report/report.js";
 import { workers } from "../../interface/resources/workers.js";
 import type { World } from "../../interface/world/world.js";
 import { createWorld, join, type CreatedWorld } from "./create.js";
 import { backToBack } from "./loop.js";
 import { blocking, counter, seed, seen, setFailAt, ticked } from "./tails.test-helper.js";
 import { System } from "../../interface/system/system.js";
-import { followReports, runReported } from "./reports.test-helper.js";
+import { catchOutOfBand, followTicks, runReported } from "./outcomes.test-helper.js";
 
 // Tails, with the world and the thread filling "tailsTest" on this one, joined through a MessageChannel.
 
@@ -22,16 +22,12 @@ const until = <T>(observe: Observe<T>, accept: (value: T) => boolean): Promise<T
     });
 });
 
-/** Once the thread shared last has status `status`. */
-const statusOf = (world: CreatedWorld, status: "joined" | "gone") =>
-    until(world.threads, threads => threads.at(-1)?.status === status);
-
 const joined = async (options: Parameters<typeof createWorld>[1] = {}, resources: Parameters<typeof createWorld>[0] = {}): Promise<{ readonly world: CreatedWorld; readonly remote: World }> => {
     const world = createWorld({ [workers]: 0, ...resources }, options);
     const channel = new MessageChannel();
-    world.share(channel.port1);
-    const remote = join(channel.port2, { threads: ["tailsTest"] });
-    await statusOf(world, "joined");
+    const shared = world.share(channel.port1);
+    const remote = await join(channel.port2, { threads: ["tailsTest"] });
+    await shared;
     return { world, remote };
 };
 
@@ -47,33 +43,39 @@ describe("tails", () => {
     });
     it("block in their tier where a body reaches its commands, which isn't terminal", async () => {
         const { world, remote } = await joined();
-        expect((await runReported(world, blocking)).warnings.map(warning => warning.name)).toEqual(["tailsTest/blocking"]);
+        expect((await runReported(world, blocking)).warnings.map(warning => warning.name)).toEqual(["blocking"]);
         await remote.dispose();
         await world.dispose();
     });
-    it("report what they throw in their run's report, and in their tick's, written after them", async () => {
+    it("fail their run with what they throw, and a tick's are reported out of band once its tails are done", async () => {
         seen.length = 0;
+        using reported = catchOutOfBand();
         const driver = backToBack();
         const { world, remote } = await joined({ loop: driver }, { [always]: true });
         await world.run(seed, { count: 10 });
         await world.run(setFailAt, { at: 1 });
-        const ran = await runReported(world, ticked);
-        expect(ran.failures.map(failure => [failure.kind, failure.name, failure.message])).toEqual([["system", "tailsTest/watch", "tailsTest failure at 1"]]);
-        const failing = await world.run(setFailAt, { at: 6 });
-        const reports = followReports(world);
+        // The run waits for its tails, and rejects with theirs.
+        await expect(world.run(ticked)).rejects.toThrow(/^System "watch" .*failed: tailsTest failure at 1$/);
+        await world.run(setFailAt, { at: 6 });
+        const ticks = followTicks(world);
         world.add(ticked);
-        const failed = await reports.until(value => value.run > failing && value.failures.length > 0);
-        expect(failed.failures.map(failure => [failure.kind, failure.name, failure.message])).toEqual([["system", "tailsTest/watch", "tailsTest failure at 6"]]);
+        const failed = await ticks.until(value => value.failures.length > 0);
+        expect(failed.failures.map(failure => [failure.kind, failure.name, failure.message])).toEqual([["system", "watch", "tailsTest failure at 6"]]);
+        await reported.until(error => error.message.includes("tailsTest failure at 6"));
+        expect(reported.messages()).toEqual([expect.stringMatching(/^System "watch" .*failed: tailsTest failure at 6$/)]);
+        ticks.stop();
         await remote.dispose();
         await world.dispose();
         driver.close();
     });
-    it("leave observer systems each tick's values at once, and one reading reports its tick's, its tails' failures in it", async () => {
+    it("leave observer systems each tick's values at once, its tails' failures reported once they're done", async () => {
+        // Ticks while the joined thread leaves skip its systems, a "thread" failure, reported too.
+        using reported = catchOutOfBand();
         const driver = backToBack();
         const { world, remote } = await joined({ loop: driver }, { [always]: true });
         await world.run(seed, { count: 10 });
         const counters: number[] = [];
-        const values = System.create({ observer: true, resources: { read: [counter] } }, ({ resources }) => { counters.push(resources[counter]); });
+        const values = System.create({ observer: true }, ({ resources }) => { counters.push(resources[counter]); });
         world.add(ticked);
         world.add(values);
         await until(Observe.resource(world, counter), value => value >= 5);
@@ -81,16 +83,9 @@ describe("tails", () => {
         // Every tick's counter once, as its sync point left it, though its tails ran on while the next tick went on.
         const first = counters.findIndex(value => value > 0);
         expect(counters.slice(first, first + 4)).toEqual([0, 1, 2, 3].map(k => counters[first] + k));
-        const reports: (readonly [number, readonly string[]])[] = [];
-        const reading = System.create({ observer: true, components: { read: [Report.errors], changed: [Report.errors] }, resources: { read: [counter] } }, (row, { resources }) => {
-            reports.push([resources[counter], row[Report.errors].failures.map(failure => failure.message)]);
-        });
-        world.add(reading);
-        const followed = followReports(world);
         const at = (await Observe.toPromise(Observe.resource(world, counter))) + 4;
         await world.run(setFailAt, { at });
-        await followed.until(value => value.failures.length > 0);
-        expect(reports.filter(([value]) => value === at).map(([, messages]) => messages)).toEqual([[`tailsTest failure at ${at}`]]);
+        await reported.until(error => error.message.includes(`tailsTest failure at ${at}`));
         await remote.dispose();
         await world.dispose();
         driver.close();
@@ -103,8 +98,8 @@ describe("tails", () => {
         const leaving = remote.dispose();
         const report = await runReported(world, ticked);
         await leaving;
-        expect(report.failures.map(failure => [failure.kind, failure.name])).toEqual([["thread", "tailsTest/lead"], ["thread", "tailsTest/watch"]]);
-        expect(report.skipped).toEqual(["tailsTest/lead", "tailsTest/watch"]);
+        expect(report.failures.map(failure => [failure.kind, failure.name])).toEqual([["thread", "lead"], ["thread", "watch"]]);
+        expect(report.skipped).toEqual(["lead", "watch"]);
         expect(await runReported(world, ticked)).toEqual({ failures: [], skipped: [], dropped: 0, warnings: [] });
         expect(seen.map(({ counter, rows, wrong }) => [counter, rows, wrong])).toEqual([[1, 10, 0], [3, 10, 0]]);
         // A registration waits for tails in flight, of which a thread that's gone has none.

package/src/implementation/world/tails.ts

@@ -1,10 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Leaf } from '../../interface/system/leaf.js';
-import type { Failure } from '../../interface/report/failure.js';
-import { declarationOf, firstKeyOf, labelOfItem } from '../../interface/registry/index.js';
+import type { Failure } from './failures.js';
+import { declarationOf, firstKeyOf } from '../../interface/registry/index.js';
 import { layoutOf, type Layout } from '../../interface/registry/layout.js';
 import { accessOf, type Schedule } from '../../interface/registry/schedule.js';
 import { stampChanged, type Archetype } from './archetype.js';
 import { readCell } from './cells.js';
+import { kernelOf } from './attach-kernel.js';
 import { indexOf, locate } from './entities.js';
 import { failureOf } from './failures.js';
 import { ownTag } from './move-log.js';
@@ -31,15 +33,15 @@ const objectsOnly = (keys: readonly Key[] | undefined): boolean =>
 /**
  * Whether a leaf is terminal: the plugin proved its body never reaches `commands`, and it writes only objects, which
  * live on its own thread, reduces into nothing, and looks nothing up, since a lookup reads the entity table the next
- * sync point rewrites. Neither a kernel nor `up`.
+ * sync point rewrites. Neither a kernel nor `up`, nor with `where`, whose points per archetype a tail's claims don't keep.
  */
 export const isTerminal = (leaf: Leaf): boolean => {
     const known = terminalLeaves.get(leaf);
     if (known !== undefined) return known;
     const { declaration } = leaf;
-    const terminal = leaf.kind === "system" && declaration.kernel === undefined && declaration.up === undefined && provenTerminal(leaf.body)
+    const terminal = leaf.kind === "system" && kernelOf(leaf) === undefined && declaration.up === undefined && declaration.components?.where === undefined && provenTerminal(leaf.body)
         && Object.keys(declaration.lookup ?? {}).length === 0
-        && (declaration.reduce === undefined || Object.getOwnPropertySymbols(declaration.reduce).length === 0)
+        && (declaration.resources?.reduce?.length ?? 0) === 0
         && objectsOnly(declaration.components?.write) && objectsOnly(declaration.resources?.write);
     terminalLeaves.set(leaf, terminal);
     return terminal;
@@ -92,6 +94,11 @@ export type Copied = {
     readonly conditionIs: readonly number[];
     readonly conditionNot: readonly number[];
     readonly query: boolean;
+    /**
+     * Whether it keeps a point per archetype, with `where` and change filters, which the world doesn't see: a snapshot
+     * of it copies every matched row, and its thread filters them.
+     */
+    readonly pointed?: boolean;
     readonly block: number;
     readonly control: Int32Array;
     snapshot: { offset: number; bytes: number } | null;
@@ -129,7 +136,7 @@ const isStruct = (state: State, id: number): boolean => state.layouts[id].kind !
 /** A runner's tail, made the first time it runs as one; its block is the channel's, freed with it. */
 export const tailOf = (state: State, runner: Runner, leaf: Leaf): Tail => {
     const remote = runner.remote;
-    if (remote === null) throw new Error(`System "${labelOfItem(leaf)}" runs as a tail only on a joined thread.`);
+    if (remote === null) throw new Error(`System "${leaf.name}" runs as a tail only on a joined thread.`);
     if (remote.tail !== null) return remote.tail;
     const { components, resources } = leaf.declaration;
     const ids = (keys: readonly Key[] | undefined): number[] => [...new Set((keys ?? []).map(key => idOf(state, key)))];
@@ -163,7 +170,7 @@ export const freeTail = (state: State, tail: Tail): void => {
 };
 
 /** What a schedule's tails gave back once their tasks settled: failures and skipped systems, null for none. */
-export type TailOutcome = { readonly failures: Failure[] | null; readonly skipped: string[] | null };
+export type TailOutcome = { readonly failures: Failure[] | null; readonly skipped: Leaf[] | null };
 
 const settledTail = (state: State, tail: Tail): void => {
     tail.unresolved = false;
@@ -196,6 +203,7 @@ export const postTails = (state: State, runners: readonly Runner[], leaves: read
     for (const runner of runners) if (runner.remote !== null && !runner.holdings.removed && !channels.includes(runner.remote.channel)) channels.push(runner.remote.channel);
     const tasks = channels.map(channel => {
         const systems: RemoteSystem[] = [];
+        const ran: Leaf[] = [];
         const order: number[] = [];
         const tails: Tail[] = [];
         for (let k = 0; k < runners.length; k++) {
@@ -204,27 +212,29 @@ export const postTails = (state: State, runners: readonly Runner[], leaves: read
             const tail = tailOf(state, runners[k], leaves[k]);
             prepare(state, tail);
             systems.push(remote);
+            ran.push(leaves[k]);
             order.push(tiers[k]);
             tails.push(tail);
         }
         return channel.run(state, systems, order, args, true).then(done => {
             for (const tail of tails) settledTail(state, tail);
-            return { done, systems };
+            return { done, systems, leaves: ran };
         });
     });
     return outcomeOf(tasks);
 };
 
-const outcomeOf = async (tasks: readonly Promise<{ readonly done: boolean; readonly systems: readonly RemoteSystem[] }>[]): Promise<TailOutcome> => {
+const outcomeOf = async (tasks: readonly Promise<{ readonly done: boolean; readonly systems: readonly RemoteSystem[]; readonly leaves: readonly Leaf[] }>[]): Promise<TailOutcome> => {
     let failures: Failure[] | null = null;
-    let skipped: string[] | null = null;
-    for (const { done, systems } of await Promise.all(tasks)) {
-        for (const system of systems) {
+    let skipped: Leaf[] | null = null;
+    for (const { done, systems, leaves } of await Promise.all(tasks)) {
+        for (let k = 0; k < systems.length; k++) {
+            const system = systems[k];
             if (!done) {
-                (failures ??= []).push(failureOf("thread", system.label, system.channel.goneError()));
-                (skipped ??= []).push(system.label);
+                (failures ??= []).push(failureOf("thread", { name: system.label, id: system.id }, system.channel.goneError(), leaves[k]));
+                (skipped ??= []).push(leaves[k]);
             }
-            else if (system.result.error !== undefined) (failures ??= []).push(failureOf("system", system.label, system.result.error));
+            else if (system.result.error !== undefined) (failures ??= []).push(failureOf("system", { name: system.label, id: system.id }, system.result.error, leaves[k]));
         }
     }
     return { failures, skipped };
@@ -276,7 +286,7 @@ const headOf = (state: State, tail: Copied): { readonly executed: boolean; reado
         if (cell !== undefined && cell.storage.changed[cell.row] > tail.lastRun) resourcesChanged = true;
     }
     const filtered = tail.added.length + tail.changed.length + tail.resourceChanged.length > 0;
-    const since = !filtered || resourcesChanged ? -1 : tail.lastRun;
+    const since = !filtered || resourcesChanged || tail.pointed === true ? -1 : tail.lastRun;
     if (!tail.query) return { executed: true, ran: since < 0, since };
     if (since >= 0 && tail.added.length + tail.changed.length === 0) return { executed: true, ran: false, since };
     return { executed: true, ran: true, since };
@@ -286,11 +296,11 @@ const filtersOf = (tail: Copied, archetype: Archetype): Filter[] => {
     const filters: Filter[] = [];
     for (const id of tail.added) {
         const storage = archetype.storageById[id];
-        if (storage !== undefined) filters.push({ ticks: storage.added, chunks: storage.chunkAdded });
+        if (storage !== undefined) filters.push({ ticks: storage.added, chunks: storage.chunkAdded, blocks: storage.blockAdded });
     }
     for (const id of tail.changed) {
         const storage = archetype.storageById[id];
-        if (storage !== undefined) filters.push({ ticks: storage.changed, chunks: storage.chunkChanged });
+        if (storage !== undefined) filters.push({ ticks: storage.changed, chunks: storage.chunkChanged, blocks: storage.blockChanged });
     }
     return filters;
 };
@@ -398,7 +408,7 @@ const markOwn = (state: State, tail: Copied, claimed: number): void => {
 
 /**
  * Before a writer of what a tail reads: unless it read everything, copies the rest from the position it reached,
- * exchanges its progress for `snapshotted`, and waits for the chunk it claimed. Null when nothing is left to wait for.
+ * adds `snapshotted` to its progress, and waits for the chunk it claimed. Null when nothing is left to wait for.
  */
 const resolve = (state: State, tail: Tail): Promise<void> | null => {
     settledTail(state, tail);
@@ -406,8 +416,8 @@ const resolve = (state: State, tail: Tail): Promise<void> | null => {
 };
 
 /**
- * Unless the reader read everything, copies the rest of what it reads from the position it reached, exchanges its
- * progress for `snapshotted`, and waits for the chunk it claimed. Null when nothing is left to wait for.
+ * Unless the reader read everything, copies the rest of what it reads from the position it reached, adds `snapshotted`
+ * to its progress, and waits for the chunk it claimed. Null when nothing is left to wait for.
  */
 export const copyRest = (state: State, tail: Copied): Promise<void> | null => {
     const { control, end } = tail;
@@ -416,7 +426,10 @@ export const copyRest = (state: State, tail: Copied): Promise<void> | null => {
     const from = Atomics.load(control, progressWord);
     runs.length = 0;
     if (from < end) writeSnapshot(state, tail, from);
-    const claimed = Atomics.exchange(control, progressWord, snapshotted);
+    // Added rather than exchanged, so a claim before the copy stays in the word: a post a claim reached is never taken
+    // for one none did (`cancel` in joined-observer.ts). Claims past it, a chunk at a time, keep the word below
+    // `cancelled` there, `snapshotted` plus at most the end and a chunk, as ends are far below their difference.
+    const claimed = Atomics.add(control, progressWord, snapshotted);
     tailWriters.copies++;
     // Rows the tail claimed while this copied it reads where they are.
     if (claimed < end) markOwn(state, tail, claimed);

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

@@ -1,5 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
-import { Component, Entity, System, workers } from "../../index.js";
+import { Entity, System, workers } from "../../index.js";
 import { createWorld } from "./create.js";
 
 const amount = Symbol("targetTest/amount");
@@ -10,25 +11,21 @@ declare module "@adobe/ecs" {
         [tagged]: { type: true };
     }
 }
-Component.register(amount, { type: { type: "number" } });
-Component.register(tagged, { type: { const: true } });
-
-const one = { type: "object", properties: { entity: Entity.schema } } as const;
 
 let spawned: Entity[] = [];
-const spawn = System.create({ name: "targetTest/spawn" }, ({ commands }) => {
+const spawn = System.create({}, ({ commands }) => {
     spawned = [commands.spawn([amount, tagged])({ [amount]: 1 }), commands.spawn([amount, tagged])({ [amount]: 2 }), commands.spawn([amount])({ [amount]: 3 })];
 });
-const bump = System.create({ name: "targetTest/bump", input: one, target: "entity", components: { write: [amount], has: [tagged] } }, row => {
+const bump = System.create({ target: "entity", components: { with: [amount, tagged] } }, (row, _context, input: { readonly entity: Entity }) => {
     row[amount] += 10;
 });
-const remove = System.create({ name: "targetTest/remove", input: one, target: "entity", components: { has: [tagged] } }, (row, { commands }) => {
+const remove = System.create({ target: "entity", components: { with: [tagged] } }, (row, { commands }, _input: { readonly entity: Entity }) => {
     commands.despawn(row.entity);
 });
 let amounts: number[] = [];
 let changed: number[] = [];
-const readAmounts = System.create({ name: "targetTest/readAmounts", observer: true, components: { read: [amount] } }, row => { amounts.push(row[amount]); });
-const watchChanged = System.create({ name: "targetTest/watchChanged", observer: true, components: { read: [amount], changed: [amount] } }, row => { changed.push(row[amount]); });
+const readAmounts = System.create({ observer: true, components: { with: [amount] } }, row => { amounts.push(row[amount]); });
+const watchChanged = System.create({ observer: true, components: { with: [amount], changed: [amount] } }, row => { changed.push(row[amount]); });
 
 const inline = () => createWorld({ [workers]: 0 });
 const amountsOf = async (world: ReturnType<typeof inline>): Promise<number[]> => {
@@ -65,9 +62,9 @@ describe("systems on one entity", () => {
 
     it("take their entity from an entity field of their input, and have components, no kernel, up, order or reduce", () => {
         // @ts-expect-error its target isn't an entity field
-        expect(() => System.create({ name: "targetTest/notEntity", input: { type: "object", properties: { count: { type: "number" } } }, target: "count", components: { has: [amount] } }, () => {}))
-            .toThrow('System "targetTest/notEntity" runs on one entity, so it takes it from an input field "count" holding an entity.');
+        expect(() => System.create({ target: "count", components: { with: [amount] } }, (_row, _context, input: { readonly count: number }) => {}))
+            .toThrow('runs on one entity, so it takes it from an input field "count" holding an entity.');
         // @ts-expect-error it needs components
-        expect(() => System.create({ name: "targetTest/noComponents", input: one, target: "entity" }, () => {})).toThrow('System "targetTest/noComponents" runs on one entity, so it needs components.');
+        expect(() => System.create({ target: "entity" }, (_context, input: { readonly entity: Entity }) => {})).toThrow('runs on one entity, so it needs components.');
     });
 });

package/src/implementation/world/terminal.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /**
  * The `Symbol.for` name of the global `WeakSet` of system bodies the plugin proved never reach their context's
  * `commands`. Its version changes with the set's format.

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

@@ -1,14 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { declarationOf, firstKeyOf, keyOfId, labelOf } from '../../interface/registry/index.js';
 import { layoutOf, viewsOf, type Layout, type Views } from '../../interface/registry/layout.js';
-import { writeOf } from './archetype.js';
+import { alias, writeOf } from './archetype.js';
+import { parseShared } from './shared.js';
 import { emptyViews } from './arrays.js';
+import { arrivalsWord, viewInMemory, type ArrivalsView } from './arrivals.js';
 import { tableLength } from './entities.js';
 import {
     archetypeField, capacityField, cursorField, entitiesVersionField, entitiesWord, freeCapacityField, freeField, generationField, linearFlag,
-    recordCapacity, recordCount, recordEntities, recordFlags, recordStorages, recordVersion, recordWords, metaFlag, remoteFlag, resourceEntityWord, resourceFlag,
-    rowField, storageAdded, storageChanged, storageChunkAdded, storageChunkChanged, storageChunks, storageColumn, storageComponent, storageFlags,
-    storageWords, tableLengthWord, tableOffsetWord, threadShift, tickedFlag,
+    reclaimedFlag, recordCapacity, recordCount, recordEntities, recordFlags, recordGeneration, recordStorages, recordVersion, recordWords, remoteFlag, replacedWord, resourceEntityWord, resourceFlag,
+    rowField, storageAdded, storageBlockAdded, storageBlockChanged, storageChanged, storageChunkAdded, storageChunkChanged, storageChunks, storageColumn,
+    storageComponent, storageFlags, storageWords, tableLengthWord, tableOffsetWord, threadShift, tickedFlag, sharedFlag,
 } from './layout-directory.js';
+import { blockShift, chunkShift } from './kernel.js';
 import { coveringBuffer, pageBytes, pagesWord } from './memory.js';
 import { createStringReader } from './strings.js';
 import type { Mirror, Mirrored } from './mirror.js';
@@ -29,8 +33,9 @@ export type ThreadArchetype = RowArchetype & {
     readonly mirrored: Mirrored | null | undefined;
     readonly components: readonly number[];
     readonly resource: boolean;
-    /** Whether it holds reports, which only queries that require a component see. */
-    readonly meta: boolean;
+    /** Reclaimed, matching no system, and how many times it was reused for other shared values (`reclaim.ts`). */
+    readonly reclaimed: boolean;
+    readonly generation: number;
     readonly storageById: readonly (ThreadStorage | undefined)[];
 };
 
@@ -65,12 +70,38 @@ export const createThreadDirectory = (memory: WebAssembly.Memory, mirror: Mirror
     const thread = mirror?.thread ?? -1;
     /** The records strings' columns name, which this thread reads. */
     const strings = createStringReader(memory);
+    /**
+     * Moved on whenever a view `archetypeAt` gave a row may have been made again: the world replaced an archetype's
+     * arrays, the views were dropped, or the mirror rebuilt. Index lookups' rows stay bound while it stays the same, so
+     * they check it rather than each archetype for every row. A mirror that begins holding an archetype needs no move:
+     * it does from the first entry naming it, replayed before any run reads a row there.
+     */
+    const replaced = { count: 0 };
+    /** The directory's `replacedWord`, and the mirror's archetypes, as this thread last saw them. */
+    let replacedSeen = 0;
+    let mirroredSeen: readonly (Mirrored | null | undefined)[] = noMirrored;
 
-    /** Views of the memory again, once it grew; every archetype's views with them. Returns its buffer. */
+    /**
+     * Moves `replaced` on if any archetype's view may have changed since it last looked: once a run, before it reads
+     * rows, since the world replaces arrays only at a sync point or a move outside one, which wait for a run in progress.
+     */
+    const settle = (): void => {
+        const word = Atomics.load(viewed.words, replacedWord);
+        const mirrored = mirror?.archetypes ?? noMirrored;
+        if (word === replacedSeen && mirrored === mirroredSeen) return;
+        replacedSeen = word;
+        mirroredSeen = mirrored;
+        replaced.count++;
+    };
+
+    /** Views of the memory again, once it grew, every archetype's with them, and `replaced` settled. Returns its buffer. */
     const refresh = (): ArrayBufferLike => {
         if (viewed.words.length === 0) viewed.words = new Uint32Array(memory.buffer);
         const current = Atomics.load(viewed.words, pagesWord);
-        if (current === pages) return viewed.buffer;
+        if (current === pages) {
+            settle();
+            return viewed.buffer;
+        }
         const latest = coveringBuffer(memory, current * pageBytes);
         if (latest.byteLength < current * pageBytes) throw new Error(`This thread's memory is ${latest.byteLength} bytes, short of the ${current * pageBytes} the world stored.`);
         viewed.buffer = latest;
@@ -78,7 +109,10 @@ export const createThreadDirectory = (memory: WebAssembly.Memory, mirror: Mirror
         viewed.views = viewsOf(latest, 0, latest.byteLength);
         pages = current;
         archetypes.length = 0;
+        // Defensive: rows bound to the old views still read the same shared memory, and arrays that moved bumped `replacedWord`.
+        replaced.count++;
         entitiesVersion = -1;
+        settle();
         return latest;
     };
 
@@ -105,13 +139,31 @@ export const createThreadDirectory = (memory: WebAssembly.Memory, mirror: Mirror
         return entities;
     };
 
+    /**
+     * By the offset of its text, each shared value read, as its archetype's storage's layout, with that text: a text's
+     * block is freed as its archetype is reused for other values (`reclaim.ts`), and may hold another's after.
+     */
+    const sharedLayouts = new Map<number, { readonly text: string; readonly layout: Layout }>();
+    const sharedLayoutAt = (offset: number): Layout => {
+        const { words, buffer } = viewed;
+        const units = new Uint16Array(buffer, offset + 4, words[offset >> 2]);
+        let text = "";
+        for (let i = 0; i < units.length; i++) text += String.fromCharCode(units[i]);
+        const known = sharedLayouts.get(offset);
+        if (known !== undefined && known.text === text) return known.layout;
+        const layout: Layout = { kind: "constant", value: parseShared(text), shared: true };
+        sharedLayouts.set(offset, { text, layout });
+        return layout;
+    };
+
     /** A storage's view, by its record's words; this thread's objects by their mirror column. */
     const storageOf = (base: number, capacity: number, mirrored: Mirrored | null | undefined): ThreadStorage | undefined => {
         const { words, buffer } = viewed;
         const component = words[base + storageComponent];
-        const layout = layouts[component];
-        if (layout === undefined) return undefined;
         const flags = words[base + storageFlags];
+        // A shared component's storage holds its archetype's value.
+        const layout = layouts[component] === undefined ? undefined : (flags & sharedFlag) !== 0 ? sharedLayoutAt(words[base + storageColumn]) : layouts[component];
+        if (layout === undefined) return undefined;
         const ticked = (flags & tickedFlag) !== 0;
         const own = (flags & remoteFlag) !== 0 && flags >>> threadShift === thread;
         const chunks = words[base + storageChunks];
@@ -129,9 +181,11 @@ export const createThreadDirectory = (memory: WebAssembly.Memory, mirror: Mirror
             ticked,
             added,
             // A constant's `changed` ticks are its `added` ticks.
-            changed: layout.kind === "constant" ? added : changed,
+            changed: alias(layout) ? added : changed,
             chunkAdded: ticked ? new Float64Array(buffer, words[base + storageChunkAdded], chunks) : noTicks,
-            chunkChanged: ticked ? new Float64Array(buffer, words[layout.kind === "constant" ? base + storageChunkAdded : base + storageChunkChanged], chunks) : noTicks,
+            chunkChanged: ticked ? new Float64Array(buffer, words[alias(layout) ? base + storageChunkAdded : base + storageChunkChanged], chunks) : noTicks,
+            blockAdded: ticked ? new Float64Array(buffer, words[base + storageBlockAdded], chunks << (chunkShift - blockShift)) : noTicks,
+            blockChanged: ticked ? new Float64Array(buffer, words[alias(layout) ? base + storageBlockAdded : base + storageBlockChanged], chunks << (chunkShift - blockShift)) : noTicks,
         };
     };
 
@@ -149,7 +203,8 @@ export const createThreadDirectory = (memory: WebAssembly.Memory, mirror: Mirror
         return {
             id, record, version, mirrored, components, storageById,
             resource: (words[record + recordFlags] & resourceFlag) !== 0,
-            meta: (words[record + recordFlags] & metaFlag) !== 0,
+            reclaimed: (words[record + recordFlags] & reclaimedFlag) !== 0,
+            generation: words[record + recordGeneration],
             entities: new Float64Array(buffer, words[record + recordEntities], capacity),
         };
     };
@@ -166,6 +221,16 @@ export const createThreadDirectory = (memory: WebAssembly.Memory, mirror: Mirror
     };
 
     const countOf = (archetype: ThreadArchetype): number => viewed.words[archetype.record + recordCount];
+    /** The ring of rows' moves, once the world wrote one, in this thread's view of the memory. */
+    let arrivalsView: ArrivalsView | null = null;
+    const arrivals = (): ArrivalsView | null => {
+        const { words } = viewed;
+        if (arrivalsView !== null && arrivalsView.control === words) return arrivalsView;
+        // Before this thread views the memory, there's nothing to read.
+        if (words.length <= arrivalsWord) return null;
+        const offset = Atomics.load(words, arrivalsWord);
+        return arrivalsView = offset === 0 ? null : viewInMemory(words, offset);
+    };
 
     /** The resource entity's archetype and row, or null before resources exist. */
     const resourceRow = (): { readonly archetype: ThreadArchetype; readonly row: number } | null => {
@@ -187,9 +252,13 @@ export const createThreadDirectory = (memory: WebAssembly.Memory, mirror: Mirror
                 if (key === undefined || keys[number] !== undefined) continue;
                 keys[number] = key;
                 numbers.set(firstKeyOf(key), number);
-                layouts[number] = layoutOf(declarationOf(key)?.type);
+                const declaration = declarationOf(key);
+                // A shared component's values are its archetypes': each storage of it holds its own.
+                layouts[number] = declaration?.shared === true ? { kind: "constant", value: undefined, shared: true } : layoutOf(declaration?.type);
                 // Views hold storages only of components with layouts here, so they're made again.
                 archetypes.length = 0;
+                // Defensive: a lookup's read keys are named before its runner and pool exist, so no bound row lacks a storage.
+                replaced.count++;
             }
         }
     };
@@ -201,8 +270,8 @@ export const createThreadDirectory = (memory: WebAssembly.Memory, mirror: Mirror
     };
 
     return {
-        viewed, rows, keys, layouts, numbers, mirror, strings,
-        refresh, refreshEntities, archetypeAt, countOf, resourceRow, tableCount, name, numberOf,
+        viewed, rows, keys, layouts, numbers, mirror, strings, replaced,
+        refresh, refreshEntities, archetypeAt, countOf, arrivals, resourceRow, tableCount, name, numberOf,
         layoutOf: (key: Key): Layout | undefined => layouts[numbers.get(firstKeyOf(key)) ?? -1],
     };
 };