@adobe/ecs 0.1.0 → 0.2.1

package/src/implementation/world/structure.ts

@@ -1,7 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Archetype } from './archetype.js';
 import type { Holders } from './holders.js';
 import { strataOf, type RuleFacts, type Strata } from '../../interface/registry/strata.js';
 import { closedComponents } from './closure.js';
+import { noteEdge } from './reclaim.js';
 
 /**
  * A world's structural derivation: its rules and `within` declarations as strata, the closure each archetype maps to,
@@ -49,12 +51,14 @@ export const restratify = (structure: Structure, rules: readonly RuleFacts[], ho
 };
 
 /** The archetype an entity with `archetype`'s components ends up in once derived. Computed once per archetype, at sync points. */
-export const closureOf = (structure: Structure, derived: readonly boolean[], archetype: Archetype, archetypeOf: (components: readonly number[]) => Archetype, archetypes: readonly Archetype[]): Archetype => {
+export const closureOf = (structure: Structure, derived: readonly boolean[], archetype: Archetype, archetypeOf: (components: readonly number[], shared: readonly (number | undefined)[]) => Archetype, archetypes: readonly Archetype[]): Archetype => {
     if (archetype.resource || structure.strata.length === 0) return archetype;
     const cached = structure.closures[archetype.id] ?? -1;
     if (cached >= 0) return archetypes[cached];
-    const closed = archetypeOf(closedComponents(archetype.components, derived, structure.hosts, structure.strata));
+    // Its shared values stay: no derived component is shared.
+    const closed = archetypeOf(closedComponents(archetype.components, derived, structure.hosts, structure.strata), archetype.shared);
     structure.closures[archetype.id] = closed.id;
+    noteEdge(structure.closures, archetype.id, undefined, archetype, closed);
     return closed;
 };
 

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import { createBlock, endBlock, generationOf, indexOf, reserve, reserveFrom } from "./entities.js";
 import { createState } from "./state.js";

package/src/implementation/world/synchronize.ts

@@ -1,11 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Views } from '../../interface/registry/layout.js';
 import { copyValue, ensureCapacity, swapRemove, writeF32, writeF32Lanes, writeF64, writeI32, writeU32, type Archetype, type Storage } from './archetype.js';
-import { chunkShift } from './kernel.js';
+import { blockShift, chunkShift } from './kernel.js';
 import { addCommand, clearBuffer, despawnCommand, endOf, referenceAt, removeCommand, spawnCommand, type CommandBuffer } from './buffer.js';
 import { readCell, writeCell } from './cells.js';
 import { commitBatches, commitStaged } from './batches.js';
 import { applyIndexChanges, cascadeReferences, indexChangesOf, type IndexChanges, type Written } from './cascade.js';
 import { refreshDirectories } from './directories.js';
+import { createArrivals, logArrival } from './arrivals.js';
+import { noteEdge, noteEmptied, reclaimEmptied } from './reclaim.js';
 import { beginStructure, countChanged, endStructure, flushDirectory } from './layout-directory.js';
 import { beginLog, logAppend, logMove, logSet, logSwap, publishLog, startTag, tagOf } from './move-log.js';
 import { record } from './journal.js';
@@ -16,7 +19,7 @@ import { settleStops } from './stop-lists.js';
 import { closureOf, derives, gainsOf } from './structure.js';
 import type { Plan } from './plan.js';
 import type { MoveLog } from './move-log.js';
-import { archetypeOf, defaultOf, movesOf, withComponent, withoutComponent, type State } from './state.js';
+import { archetypeOf, movesOf, sharedNumberOf, withComponent, withoutComponent, withShared, type State } from './state.js';
 import { releaseValue } from './transfers.js';
 
 /** Buffers queued for the next sync point, in merge order. Commands in guarded buffers can't touch the resource entity. */
@@ -154,7 +157,7 @@ const planOf = (state: State, queued: readonly Queued[], written: Written): void
                 const start = starts[command];
                 const end = endOf(buffer, command);
                 let to = archetypes[empty];
-                for (let k = start; k < end; k++) to = withComponent(state, to, ids[k]);
+                for (let k = start; k < end; k++) to = state.shared[ids[k]] === undefined ? withComponent(state, to, ids[k]) : withShared(state, to, ids[k], sharedNumberOf(state, ids[k], buffer.values[k]));
                 plan.to[entry] = to.id;
                 if (end > start) addRange(state, entry, b, start, end);
                 if (references) for (let k = start; k < end; k++) if (structure.references[ids[k]] !== 0) written.push(entity, ids[k], referenceAt(buffer, k));
@@ -199,12 +202,17 @@ const planOf = (state: State, queued: readonly Queued[], written: Written): void
                     to = withoutComponent(state, to, ids[k]);
                     if (within) to = withoutDependents(state, to, ids[k]);
                 }
-                if (shape !== null) shape.removing[source] = to.id;
+                if (shape !== null) {
+                    shape.removing[source] = to.id;
+                    noteEdge(shape.removing, source, undefined, archetypes[source], to);
+                }
                 plan.to[entry] = to.id;
                 continue;
             }
             const from = plan.from[entry] < 0 ? null : archetypes[plan.from[entry]];
-            const known = shape === null ? undefined : shape.adding[to.id];
+            // A list naming a shared component goes where its values say, so its target isn't kept by source.
+            const keeps = shape !== null && shape.shared.length === 0;
+            const known = keeps ? shape.adding[to.id] : undefined;
             const source = to.id;
             for (let k = start; k < end; k++) {
                 const id = ids[k];
@@ -214,11 +222,14 @@ const planOf = (state: State, queued: readonly Queued[], written: Written): void
                     if (fresh === undefined) plan.fresh.set(entry, fresh = []);
                     fresh.push(id);
                 }
-                if (known === undefined) to = withComponent(state, to, id);
+                if (known === undefined) to = state.shared[id] === undefined ? withComponent(state, to, id) : withShared(state, to, id, sharedNumberOf(state, id, buffer.values[k]));
                 if (references && structure.references[id] !== 0) written.push(entity, id, referenceAt(buffer, k));
             }
             if (known !== undefined) to = archetypes[known];
-            else if (shape !== null) shape.adding[source] = to.id;
+            else if (keeps) {
+                shape.adding[source] = to.id;
+                noteEdge(shape.adding, source, undefined, archetypes[source], to);
+            }
             plan.to[entry] = to.id;
             if (end > start) addRange(state, entry, b, start, end);
         }
@@ -280,10 +291,12 @@ const writeRange = (buffer: CommandBuffer, start: number, end: number, to: Arche
         // A constant's `changed` ticks are its `added` ticks, and its value can't change: only a new start stamps it.
         if (storage.changed !== storage.added || starts) {
             storage.changed[toRow] = tick;
+            storage.blockChanged[toRow >> blockShift] = tick;
             storage.chunkChanged[toRow >> chunkShift] = tick;
         }
         if (starts) {
             storage.added[toRow] = tick;
+            storage.blockAdded[toRow >> blockShift] = tick;
             storage.chunkAdded[toRow >> chunkShift] = tick;
         }
     }
@@ -292,10 +305,12 @@ const writeRange = (buffer: CommandBuffer, start: number, end: number, to: Arche
 /** Writes a derived component's default into a row it starts in, stamped as added. */
 export const writeDefault = (state: State, storage: Storage, row: number, tick: number): void => {
     // A joined thread's object starts there, as the row's move or append says.
-    if (storage.remote === null) writeCell(storage, row, defaultOf(state.keys[storage.component]));
+    // One start per world, never one per row: values are replaced whole, so a shared start is never changed.
+    if (storage.remote === null) writeCell(storage, row, state.starts[storage.component]);
     else storage.tags[row] = startTag;
     if (!storage.ticked) return;
     storage.added[row] = storage.changed[row] = tick;
+    storage.blockAdded[row >> blockShift] = storage.blockChanged[row >> blockShift] = tick;
     storage.chunkAdded[row >> chunkShift] = storage.chunkChanged[row >> chunkShift] = tick;
 };
 
@@ -415,7 +430,10 @@ const copyColumn = (from: Storage, to: Storage, plan: Plan, order: Int32Array, f
         const changed = from.changed[fromRow];
         to.added[toRow] = added;
         to.changed[toRow] = changed;
-        // A chunk's tick is the newest of its rows, so a row moving in can raise it.
+        // A block's and a chunk's tick are the newest of their rows, so a row moving in can raise them.
+        const block = toRow >> blockShift;
+        if (added > to.blockAdded[block]) to.blockAdded[block] = added;
+        if (changed > to.blockChanged[block]) to.blockChanged[block] = changed;
         const chunk = toRow >> chunkShift;
         if (added > to.chunkAdded[chunk]) to.chunkAdded[chunk] = added;
         if (changed > to.chunkChanged[chunk]) to.chunkChanged[chunk] = changed;
@@ -464,6 +482,8 @@ const arrive = (state: State, queued: readonly Queued[], tick: number, deriving:
         if (from !== null) {
             const moves = movesOf(from, to);
             for (let m = 0; m < moves.length; m += 2) copyColumn(moves[m], moves[m + 1], plan, order, first, count, toStart);
+            // Systems with `where` and change filters read it, a joined thread's included.
+            if (state.arrivals || state.claimed) logArrival(state.arrivalRing ??= createArrivals(state.memory), from.id, to.id, tick);
         }
         if (state.claimed) noteArrivals(state, from, to, first, count, toStart);
         // Rows are reused after swap-removes, so a derived component starting here gets its default written.
@@ -557,7 +577,7 @@ const rederive = (state: State): void => {
     structure.rederive = false;
     for (const archetype of [...archetypes]) {
         if (archetype.resource || archetype.count === 0) continue;
-        const closed = closureOf(structure, state.derived, archetype, components => archetypeOf(state, components), archetypes);
+        const closed = closureOf(structure, state.derived, archetype, (components, shared) => archetypeOf(state, components, shared), archetypes);
         if (closed === archetype) continue;
         for (let row = 0; row < archetype.count; row++) {
             const entity = archetype.entities[row];
@@ -598,10 +618,19 @@ const cleanUp = (state: State, queued: readonly Queued[]): void => {
     }
 };
 
-/** Whether a sync point would apply anything: commands queued, entities reserved or carried, rules to derive again, or failures to report. */
+/** Whether any queued buffer holds commands. */
+const anyCommands = (queued: readonly Queued[]): boolean => {
+    for (let k = 0; k < queued.length; k++) if (queued[k].buffer.count !== 0) return true;
+    return false;
+};
+
+/** The queue a sync point takes while nothing is queued, shared, since none is written to. */
+const noneQueued: readonly Queued[] = [];
+
+/** Whether a sync point would apply anything: commands queued, entities reserved or carried, rules to derive again, or failures to give. */
 export const syncPending = (state: State, queued: readonly Queued[] = state.queued): boolean =>
-    !queued.every(({ buffer }) => buffer.count === 0) || reserved(state.entities) || state.carried !== null || state.structure.rederive
-    // Failures for its report, as a gone thread's stops it never finalized are.
+    anyCommands(queued) || reserved(state.entities) || state.carried !== null || state.structure.rederive
+    // Failures for its run, as a gone thread's stops it never finalized are.
     || state.unplaced.length > 0;
 
 /**
@@ -613,10 +642,19 @@ export const syncPending = (state: State, queued: readonly Queued[] = state.queu
 export const prepareSync = (state: State, isolated = false): boolean => {
     if (!isolated) activate(state);
     // Taken first, so a sync point that throws can't replay its commands into the next one.
-    const queued = state.queued.splice(0);
-    const { structure, plan } = state;
+    const queued = state.queued.length === 0 ? noneQueued : state.queued.splice(0);
     // Finalizers' spawns are reserved during the last sync point, so their batches are pending without a reservation.
     if (!syncPending(state, queued)) return false;
+    preparePending(state, queued, isolated);
+    return true;
+};
+
+/**
+ * `prepareSync` once something is pending: apart, so a sync point with nothing to apply allocates none of the context
+ * its closures share.
+ */
+const preparePending = (state: State, queued: readonly Queued[], isolated: boolean): void => {
+    const { structure, plan } = state;
     // Finalizers see indexes as of before the sync point applies, with nothing it spawns or moves.
     if (!isolated) refreshFinalizerIndexes(state);
     plan.count = 0;
@@ -638,7 +676,7 @@ export const prepareSync = (state: State, isolated = false): boolean => {
         const tick = ++state.tick;
         for (let k = 0; k < state.logs.length; k++) beginLog(state.logs[k], tick);
         const deriving = derives(structure);
-        const close = (archetype: Archetype): Archetype => closureOf(structure, state.derived, archetype, components => archetypeOf(state, components), state.archetypes);
+        const close = (archetype: Archetype): Archetype => closureOf(structure, state.derived, archetype, (components, shared) => archetypeOf(state, components, shared), state.archetypes);
         const born = new Map<number, number>();
         // Before the plan, so commands against staged entities find them, and before any growth, which copies `count`
         // rows.
@@ -678,7 +716,6 @@ export const prepareSync = (state: State, isolated = false): boolean => {
         }
         presize(state);
         state.syncing = { queued, reservations, reserved: state.entities.length, tick, born, index, deriving, isolated, unreserved };
-        return true;
     }
     catch (error) {
         // The next sync point's leak scan frees reservations whose spawns this one dropped.
@@ -728,6 +765,12 @@ export const applySync = (state: State): readonly Thrown[] => {
             for (let index = reservations.firstNew; index < tableLength; index++) if (leaked(index)) release(state.entities, index);
         }
         recycle(state.memory, state.entities);
+        state.syncs++;
+        // Archetypes of shared values left empty are reclaimed once they stayed so (`reclaim.ts`).
+        if (state.sharing) {
+            noteEmptied(state);
+            reclaimEmptied(state);
+        }
     }
     finally {
         cleanUp(state, queued);

package/src/implementation/world/tail-blocks.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { lineWords } from './protocol.js';
 
 // What the world's thread and a joined thread share to run a tail (threads.md, "Tails"): a block per tail system, of
@@ -5,10 +6,11 @@ import { lineWords } from './protocol.js';
 //
 // A tail's work is numbered: position 0 is its head, which checks its conditions and resolves its resources, and
 // positions from 1 are the rows of its matched archetypes in order. The tail claims positions in chunks by adding to
-// its progress word; the world exchanges that word for `snapshotted` once it copied the passing rows from the position
-// it read, so a claim that returns `snapshotted` or more reads the rest from the copy.
+// its progress word; the world adds `snapshotted` to that word once it copied the passing rows from the position it
+// read, so a claim that returns `snapshotted` or more reads the rest from the copy, and the word still says whether a
+// claim came before the copy.
 
-/** The positions the tail claimed, which it adds to and the world exchanges; and the end of its work, 1 plus its rows. */
+/** The positions the tail claimed, which it and the world add to; and the end of its work, 1 plus its rows. */
 export const progressWord = 0;
 export const endWord = 1;
 /** The position the tail finished reading through, which it stores after each chunk; whether the world waits for it. */
@@ -27,7 +29,10 @@ export const snapshotCapacityWord = 2 * lineWords + 6;
 export const tailBlockWords = 3 * lineWords;
 export const tailBlockBytes = tailBlockWords * 4;
 
-/** What the progress word holds once the world copied the rest: claims add to it and stay past it. */
+/**
+ * What the world adds to the progress word once it copied the rest, `snapshotted` itself when no claim came first:
+ * claims add to it and stay past it.
+ */
 export const snapshotted = 0x40000000;
 /** Positions a claim takes: the most the world waits for once a writer is ready. */
 export const tailChunk = 64;

package/src/implementation/world/tails-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 { requireDefinition } from "../../interface/registry/index.js";
 import { workers } from "../../interface/resources/workers.js";
-import { createWorld, join } from "./create.js";
+import { createWorld, join, recorderOf } from "./create.js";
 import { scopeChannel } from "./port.js";
 import { changed, gate, seed, seen, tailSystems, ticked, type Seen } from "./tails.test-helper.js";
 import { tailSnapshots } from "./thread-systems.js";
-import { reportOf, runReported } from "./reports.test-helper.js";
+import { reportOf, runReported } from "./outcomes.test-helper.js";
 
 /**
  * A thread joining a world through the port it's sent, claiming "tailsTest", whose systems it imports: it tells what
@@ -30,20 +31,15 @@ const channel = scopeChannel<FromTailsWorker, ToTailsWorker>();
 const leaveQueued = async (): Promise<FromTailsWorker> => {
     const world = createWorld({ [workers]: 0 });
     const { port1, port2 } = new MessageChannel();
-    world.share(port1);
-    const remote = join(port2, { threads: ["tailsTest"] });
-    await new Promise<void>(resolve => {
-        const stop = world.threads(threads => {
-            if (threads[0]?.status !== "joined") return;
-            queueMicrotask(() => stop());
-            resolve();
-        });
-    });
+    const shared = world.share(port1);
+    const remote = await join(port2, { threads: ["tailsTest"] });
+    await shared;
     await world.run(seed, { count: 10 });
     await world.run(ticked);
     const leaving = remote.dispose();
+    recorderOf(world);
     const runs = [world.run(ticked), world.run(ticked)];
-    const reports = await Promise.all((await Promise.all(runs)).map(run => reportOf(world, run)));
+    const reports = await Promise.all(runs.map(run => reportOf(world, run)));
     await leaving;
     const after = await runReported(world, ticked);
     await world.dispose();
@@ -55,7 +51,7 @@ channel.onMessage(async message => {
     if (message.kind === "leave queued") channel.post(await leaveQueued());
     else if (message.kind === "join") {
         for (const system of tailSystems) requireDefinition(system);
-        join(message.port, { threads: ["tailsTest"] });
+        await join(message.port, { threads: ["tailsTest"] });
         channel.post({ kind: "joined" });
     }
     else if (message.kind === "gate") {

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import type * as Fixture from "./tails.fixture.js";
 
@@ -6,7 +7,7 @@ export const tailsCases = (load: () => Promise<typeof Fixture>) => describe("tai
     it("see one tick's values in every run while the world ticks on: in place, from a snapshot when late, and both across a switch at a chunk", async () => {
         const fixture = await load();
         const seen = await fixture.continuous();
-        expect({ wrong: seen.wrong, labels: seen.labels, fewest: seen.fewest, most: seen.most }).toEqual({ wrong: 0, labels: 0, fewest: 1000, most: 1000 });
+        expect({ wrong: seen.wrong, labels: seen.labels, fewest: seen.fewest, most: seen.most, lacking: seen.lacking }).toEqual({ wrong: 0, labels: 0, fewest: 1000, most: 1000, lacking: true });
         expect(seen.late).toBeGreaterThan(0);
         expect(seen.switched).toBeGreaterThan(0);
     }, 30000);
@@ -38,7 +39,7 @@ export const tailsCases = (load: () => Promise<typeof Fixture>) => describe("tai
     }, 30000);
     it("are skipped in every run queued when their thread left, and nothing waits for a tail on a thread that's gone", async () => {
         const fixture = await load();
-        const skipped = ["tailsTest/lead", "tailsTest/watch"];
+        const skipped = ["lead", "watch"];
         expect(await fixture.leaveQueued()).toEqual({ skipped: [skipped, skipped], after: 0 });
     }, 30000);
 });

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

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /// <reference types="node" />
 import { Observe } from "../../observe/index.js";
 import { always } from "../../interface/resources/always.js";
@@ -58,10 +59,10 @@ const until = <T>(observe: Observe<T>, accept: (value: T) => boolean): Promise<T
 
 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 };
 };
 
@@ -80,6 +81,8 @@ const summary = async (worker: Worker) => {
         runs: seen.length,
         wrong: seen.reduce((sum, run) => sum + run.wrong, 0),
         labels: seen.reduce((sum, run) => sum + run.labels, 0),
+        // Rows of the archetype without `extra`, which every run reads as undefined.
+        lacking: seen.every(run => run.lacking * 2 === run.rows),
         fewest: Math.min(...seen.map(run => run.rows)),
         most: Math.max(...seen.map(run => run.rows)),
         late: reply.late,

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

@@ -1,6 +1,7 @@
-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 type { Schema } from "../../interface/schema/schema.js";
+import type { Vec3 } from "../../interface/math/index.js";
 
 // Keys and systems both threads of the tails fixtures import: a world system writing every row's stamp each tick, and
 // terminal systems on thread "tailsTest", which a joined thread fills, running there as tails.
@@ -14,43 +15,38 @@ export const spawning = Symbol("tailsTest/spawning");
 export const failAt = Symbol("tailsTest/failAt");
 export const canvas = Symbol("tailsTest/canvas");
 export const word = Symbol("tailsTest/word");
+/** On every other row: rows without it are in an archetype of their own, so a tail's optional read of it tells them apart. */
+export const extra = Symbol("tailsTest/extra");
+/** Shared, 1 on rows with `extra` and 2 on the rest: a tail reads it from each row's archetype, in place or from a snapshot. */
+export const tint = Symbol("tailsTest/tint");
 declare module "@adobe/ecs" {
     export interface Threads {
         tailsTest: true;
     }
     export interface Components {
-        [stamp]: { type: number };
-        [spot]: { type: readonly [number, number, number] };
-        [label]: { type: { readonly text: string } | null; thread: "tailsTest" };
+        [stamp]: { type: Schema.Type<{ type: "integer" }> };
+        [spot]: { type: Vec3 };
+        [label]: { type: { readonly text: string } | null; thread: "tailsTest"; default: null };
         [word]: { type: string };
+        [extra]: { type: Schema.Type<{ type: "integer" }> };
+        [tint]: { type: 1 | 2; shared: true };
     }
     export interface Resources {
-        [counter]: { type: number };
-        [stall]: { type: { readonly mode: number; readonly pause: number } };
-        [spawning]: { type: number };
-        [failAt]: { type: number };
-        [canvas]: { type: { readonly text: string }; thread: "tailsTest" };
+        [counter]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
+        [stall]: { type: Schema.Type<{ type: "object"; properties: { mode: { type: "integer" }; pause: { type: "number" } } }>; default: { mode: 0; pause: 0 } };
+        [spawning]: { type: Schema.Type<{ type: "integer" }>; default: 0 };
+        [failAt]: { type: Schema.Type<{ type: "integer" }>; default: -1 };
+        [canvas]: { type: { readonly text: string }; thread: "tailsTest"; default: { text: "canvas" } };
     }
 }
-Component.register(stamp, { type: { type: "integer" } });
-Component.register(spot, { type: { type: "array", items: { type: "number", precision: 1 }, minItems: 3, maxItems: 3 } });
 /** An object of the tail's thread, which the tail writes. */
 const text = { type: "object", properties: { text: { type: "string" } } } as const;
-Component.register(label, { type: { anyOf: [text, { type: "null" }], default: null }, thread: "tailsTest" });
 /** A string the world writes each tick, which lives in shared memory where the tail reads it. */
-Component.register(word, { type: { type: "string" } });
-Resource.register(counter, { type: { type: "integer", default: 0 } });
 /**
  * How the tails stall, for milliseconds `pause`: `"none"`, `"chunk"` in the watcher at the end of its first chunk, so
  * a writer is ready mid-way, or `"before"` in a tail ahead of it, so the watcher is late.
  */
-Resource.register(stall, {
-    type: { type: "object", properties: { mode: { type: "integer" }, pause: { type: "number" } }, required: ["mode", "pause"], default: { mode: 0, pause: 0 } },
-});
-Resource.register(spawning, { type: { type: "integer", default: 0 } });
-Resource.register(failAt, { type: { type: "integer", default: -1 } });
 /** An object resource of the tail's thread, which places the systems reading it there. */
-Resource.register(canvas, { type: { ...text, default: { text: "canvas" } }, thread: "tailsTest" });
 
 export const noStall = 0;
 export const stallAtChunk = 1;
@@ -62,49 +58,56 @@ const spin = (milliseconds: number): void => {
 };
 
 /** On the world's thread: the counter moves on once a tick. */
-export const count = System.create({ name: "tailsTest/count", resources: { write: [counter] } }, ({ resources }) => {
+export const count = System.create({}, ({ resources }) => {
     resources[counter] += 1;
 });
 /** A tick's word, of a length that varies with it, so records of every size are freed and reused. */
 export const wordOf = (value: number): string => `${"·".repeat(value % 37)}${value}`;
 
 /** On the world's thread: every row's stamp, spot and word take the counter. */
-export const advance = System.create({ name: "tailsTest/advance", components: { write: [stamp, spot, word] }, resources: { read: [counter] }, after: [count] }, (row, { resources }) => {
+export const advance = System.create({ components: { with: [stamp, spot, word], optional: [extra] }, after: [count] }, (row, { resources }) => {
     const value = resources[counter];
     row[stamp] = value;
+    if (row[extra] !== undefined) row[extra] = value;
     row[spot] = [value, -value, value];
     row[word] = wordOf(value);
 });
 /** On the world's thread: every row's word as another, of the size of the first ticks', so their records are reused. */
-export const reword = System.create({ name: "tailsTest/reword", input: { type: "object", properties: { round: { type: "integer" } } }, components: { write: [word] } }, (row, { input }) => {
+export const reword = System.create({ components: { with: [word] } }, (row, _context, input: { readonly round: number }) => {
     row[word] = `r${input.round}`;
 });
 /** On the world's thread: spawns rows stamped with this tick's counter, `spawning` of them, then no more. */
-export const grow = System.create({ name: "tailsTest/grow", resources: { read: [counter], write: [spawning] }, after: [count] }, ({ resources, commands }) => {
+export const grow = System.create({ after: [count] }, ({ resources, commands }) => {
     const value = resources[counter];
-    for (let k = 0; k < resources[spawning]; k++) commands.spawn([stamp, spot, label, word])({ [stamp]: value, [spot]: [value, -value, value], [word]: wordOf(value) });
+    for (let k = 0; k < resources[spawning]; k++) {
+        if (k % 2 === 0) commands.spawn([stamp, spot, label, word, extra, tint], { [tint]: 1 })({ [stamp]: value, [spot]: [value, -value, value], [word]: wordOf(value), [extra]: value });
+        else commands.spawn([stamp, spot, label, word, tint], { [tint]: 2 })({ [stamp]: value, [spot]: [value, -value, value], [word]: wordOf(value) });
+    }
     resources[spawning] = 0;
 });
 /** Spawns `count` rows. */
-export const seed = System.create({ name: "tailsTest/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
-    for (let k = 0; k < input.count; k++) commands.spawn([stamp, spot, label, word])({ [stamp]: 0, [spot]: [0, 0, 0], [word]: wordOf(0) });
+export const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
+    for (let k = 0; k < input.count; k++) {
+        if (k % 2 === 0) commands.spawn([stamp, spot, label, word, extra, tint], { [tint]: 1 })({ [stamp]: 0, [spot]: [0, 0, 0], [word]: wordOf(0), [extra]: 0 });
+        else commands.spawn([stamp, spot, label, word, tint], { [tint]: 2 })({ [stamp]: 0, [spot]: [0, 0, 0], [word]: wordOf(0) });
+    }
 });
-export const setStall = System.create({ name: "tailsTest/setStall", input: { type: "object", properties: { mode: { type: "integer" }, pause: { type: "number" } } }, resources: { write: [stall] } }, ({ input, resources }) => {
+export const setStall = System.create({}, ({ resources }, input: { readonly mode: number; readonly pause: number }) => {
     resources[stall] = { mode: input.mode, pause: input.pause };
 });
-export const setSpawning = System.create({ name: "tailsTest/setSpawning", input: { type: "object", properties: { count: { type: "integer" } } }, resources: { write: [spawning] } }, ({ input, resources }) => {
+export const setSpawning = System.create({}, ({ resources }, input: { readonly count: number }) => {
     resources[spawning] = input.count;
 });
-export const setFailAt = System.create({ name: "tailsTest/setFailAt", input: { type: "object", properties: { at: { type: "integer" } } }, resources: { write: [failAt] } }, ({ input, resources }) => {
+export const setFailAt = System.create({}, ({ resources }, input: { readonly at: number }) => {
     resources[failAt] = input.at;
 });
 
 /** What each run of the watcher saw, by the counter it read: rows, and those whose structs, word or label weren't that tick's. */
-export type Seen = { counter: number; rows: number; wrong: number; labels: number };
+export type Seen = { counter: number; rows: number; wrong: number; labels: number; lacking: number };
 export const seen: Seen[] = [];
 
 /** On the tail's thread, ahead of the watcher: stalls it while `stall` says so, so it's late. */
-export const lead = System.create({ name: "tailsTest/lead", resources: { read: [stall, canvas] } }, ({ resources }) => {
+export const lead = System.create({}, ({ resources }) => {
     if (resources[stall].mode === stallBefore && resources[canvas].text === "canvas") spin(resources[stall].pause);
 });
 
@@ -113,11 +116,15 @@ export const lead = System.create({ name: "tailsTest/lead", resources: { read: [
  * must be the last tick's where it wrote one.
  */
 export const watch = System.create({
-    name: "tailsTest/watch", components: { read: [stamp, spot, word], write: [label] }, resources: { read: [counter, stall, failAt] }, after: [advance, grow, lead],
+    components: { with: [stamp, spot, word, label, tint], optional: [extra] }, after: [advance, grow, lead],
 }, (row, { resources }) => {
     const value = resources[counter];
     let last = seen.at(-1);
-    if (last === undefined || last.counter !== value) seen.push(last = { counter: value, rows: 0, wrong: 0, labels: 0 });
+    if (last === undefined || last.counter !== value) seen.push(last = { counter: value, rows: 0, wrong: 0, labels: 0, lacking: 0 });
+    const more = row[extra];
+    if (more === undefined) last.lacking++;
+    else if (more !== value) last.wrong++;
+    if (row[tint] !== (more === undefined ? 2 : 1)) last.wrong++;
     if (resources[failAt] === value) throw new Error(`tailsTest failure at ${value}`);
     const [x, y, z] = row[spot];
     if (row[stamp] !== value || x !== value || y !== -value || z !== value || row[word] !== wordOf(value)) last.wrong++;
@@ -129,7 +136,7 @@ export const watch = System.create({
 });
 
 /** Not terminal: it reaches its commands, so its tier blocks. */
-export const blocking = System.create({ name: "tailsTest/blocking", components: { read: [label] } }, (row, { commands }) => {
+export const blocking = System.create({ components: { with: [label] } }, (row, { commands }) => {
     if (row[label]?.text === "never") commands.despawn(row.entity);
 });
 
@@ -139,7 +146,7 @@ export const changed = new Map<number, number>();
  * On the tail's thread, ahead of the watcher, reaching its commands, so its tier blocks: counts the labels the watcher
  * wrote since it last ran, which it sees once the world stamped them, from the watcher's snapshot too.
  */
-export const tally = System.create({ name: "tailsTest/tally", components: { read: [label], changed: [label] }, resources: { read: [counter] }, after: [count], before: [watch] }, (row, { resources, commands }) => {
+export const tally = System.create({ components: { with: [label], changed: [label] }, after: [count], before: [watch] }, (row, { resources, commands }) => {
     if (row[label]?.text === "never") commands.despawn(row.entity);
     changed.set(resources[counter], (changed.get(resources[counter]) ?? 0) + 1);
 });
@@ -148,19 +155,19 @@ export const tally = System.create({ name: "tailsTest/tally", components: { read
 export const gate: { words: Int32Array | null } = { words: null };
 
 /** On the tail's thread, terminal, reading only that thread's objects: held in its body until the world opens the gate. */
-export const held = System.create({ name: "tailsTest/held", resources: { read: [canvas] } }, ({ resources }) => {
+export const held = System.create({}, ({ resources }) => {
     const { words } = gate;
     if (words === null || resources[canvas].text !== "canvas") return;
     Atomics.store(words, 1, 1);
     Atomics.notify(words, 1);
     Atomics.wait(words, 0, 0);
 });
-export const heldTick = System.create({ name: "tailsTest/heldTick", systems: [held] });
+export const heldTick = System.create({ systems: [held] });
 
 /** Every tick: the world's systems, then the tails. */
-export const ticked = System.create({ name: "tailsTest/ticked", systems: [count, advance, grow, lead, watch] });
+export const ticked = System.create({ systems: [count, advance, grow, lead, watch] });
 /** The same, with `tally` counting what the watcher wrote. */
-export const tallied = System.create({ name: "tailsTest/tallied", systems: [count, advance, grow, lead, tally, watch] });
+export const tallied = System.create({ systems: [count, advance, grow, lead, tally, watch] });
 
 /** Every system the joined thread runs, which it imports so the world can place them there. */
 export const tailSystems: readonly System<void>[] = [ticked, tallied, blocking, heldTick];